DSpace User Interface built on Angular
Repo DSpace/dspace-angular, read from GitHub 1 min ago. DSpace has not joined Take My Repo.
DSpace/dspace-angular is a public repo on GitHub by DSpace. DSpace User Interface built on Angular. It declares the BSD-3-Clause license on GitHub. It is written mainly in TypeScript, has 181 stars and last changed on 2026-11-17. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-20.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
The DSpace User Interface built on Angular, written in TypeScript and using Angular Universal.
DSpace open source software is a turnkey repository application used by more than 2,000 organizations and institutions worldwide to provide durable access to digital resources. For more information, visit https://dspace.org/
DSpace consists of both a Java-based backend and an Angular-based frontend.
On our wiki, you may also find a list of all past releases, including their current levels of support.
Documentation for each release may be viewed online or downloaded via our Documentation Wiki.
The latest DSpace Installation instructions are available at: https://wiki.lyrasis.org/display/DSDOC10x/Installing+DSpace
Ensure you're running Node v20.x, v22.x or v24.x, npm >= v10.x
# clone the repo git clone https://github.com/DSpace/dspace-angular.git # change directory to our repo cd dspace-angular # install the local dependencies npm install # start the server npm start
Then go to http://localhost:4000 in your browser
Not sure where to start? watch the training videos linked in the Introduction to the technology section below.
You can find more information on the technologies used in this project (Angular.io, Angular CLI, Typescript, Angular Universal, RxJS, etc) on the LYRASIS wiki
v20.x, v22.x or v24.xIf you have nvm or nvm-windows installed, which is highly recommended, you can run nvm install --lts && nvm use to install and start using the latest Node LTS.
npm install to install the local dependenciesDefault runtime configuration file is located in config/ folder. These configurations can be changed without rebuilding the distribution.
To override the default configuration values, create local files that override the parameters you need to change. You can use config.example.yml as a starting point.
config.(dev or development).yml file in config/ for a development environment;config.(prod or production).yml file in config/ for a production environment;The settings can also be overwritten using an environment file or environment variables.
This file should be called .env and be placed in the project root.
The following non-convention settings:
DSPACE_HOST # The host name of the angular application DSPACE_PORT # The port number of the angular application DSPACE_NAMESPACE # The namespace of the angular application DSPACE_SSL # Whether the angular application uses SSL [true/false]
All other settings can be set using the following convention for naming the environment variables:
. with _DSPACE_e.g.
# The host name of the REST application rest.host => DSPACE_REST_HOST # The port number of the REST application rest.port => DSPACE_REST_PORT # The namespace of the REST application rest.nameSpace => DSPACE_REST_NAMESPACE # Whether the angular REST uses SSL [true/false] rest.ssl => DSPACE_REST_SSL cache.msToLive.default => DSPACE_CACHE_MSTOLIVE_DEFAULT auth.ui.timeUntilIdle => DSPACE_AUTH_UI_TIMEUNTILIDLE
The equavelant to the non-conventional legacy settings:
DSPACE_UI_HOST => DSPACE_HOST DSPACE_UI_PORT => DSPACE_PORT DSPACE_UI_NAMESPACE => DSPACE_NAMESPACE DSPACE_UI_SSL => DSPACE_SSL
The same settings can also be overwritten by setting system environment variables instead, E.g.:
export DSPACE_HOST=demo.dspace.org export DSPACE_UI_PORT=4000
The priority works as follows: environment variable overrides variable in .env file overrides external config set by DSPACE_APP_CONFIG_PATH overrides config.(prod or dev).yml
These configuration sources are collected at run time, and written to dist/browser/assets/config.json for production and src/app/assets/config.json for development.
The configuration file can be externalized by using environment variable DSPACE_APP_CONFIG_PATH.
Buildtime configuration must defined before build in order to include in transpiled JavaScript. This is primarily for the server. These settings can be found under src/environment/ folder.
To override the default configuration values for development, create local file that override the build time parameters you need to change.
environment.(dev or development).ts file in src/environment/ for a development environment;If needing to update default configurations values for production, update local file that override the build time parameters you need to change.
environment.production.ts file in src/environment/ for a production environment;The environment object is provided for use as import in code and is extended with the runtime configuration on bootstrap of the application.
Take caution moving runtime configs into the buildtime configuration. They will be overwritten by what is defined in the runtime config on bootstrap.
To use environment variables in a UI component, use:
import { AppConfig, APP_CONFIG } from 'src/config/app-config.interface'; ... constructor(@Inject(APP_CONFIG) private appConfig: AppConfig) {} ...
or
import { environment } from '../environment.ts';
After you have installed all dependencies you can now run the app. Run npm run start:dev to start a local server which will watch for changes, rebuild the code, and reload the server for you. You can visit it at http://localhost:4000.
When building for production we're using Ahead of Time (AoT) compilation. With AoT, the browser downloads a pre-compiled version of the application, so it can render the application immediately, without waiting to compile the app first. The compiler is roughly half the size of Angular itself, so omitting it dramatically reduces the application payload.
To build the app for production and start the server (in one command) run:
npm start
This will run the application in an instance of the Express server, which is included.
If you only want to build for production, without starting, run:
npm run build:prod
This will build the application and put the result in the dist folder. You can copy this folder to wherever you need it for your application server. If you will be using the built-in Express server, you'll also need a copy of the node_modules folder tucked inside your copy of dist.
After building the app for production, it can be started by running:
npm run serve:ssr
NOTE: At this time, we do not have production-ready Docker images for DSpace. That said, we do have quick-start Docker Compose scripts for development or testing purposes.
# clean everything, including node_modules. You'll need to run npm install again afterwards. npm run clean # clean files generated by the production build (.ngfactory files, css files, etc) npm run clean:prod # cleans the distribution directory npm run clean:dist
If you would like to contribute by testing a Pull Request (PR), here's how to do so. Keep in mind, you do not need to have a DSpace backend / REST API installed locally to test a PR. By default, the dspace-angular project points at our demo REST API
npm run clean (This resets your local dependencies to ensure you are up-to-date with this PR)npm install (Updates your local dependencies to those in the PR)npm start (Rebuilds the project, and deploys to localhost:4000, by default)Once you have tested the Pull Request, please add a comment and/or approval to the PR to let us know whether you found it to be successful (or not). Thanks!
Unit tests use the Jasmine test framework, and are run via Karma.
You can find the Karma configuration file at the same level of this README file:./karma.conf.js If you are going to use a remote test environment you need to edit the ./karma.conf.js. Follow the instructions you will find inside it. To executing tests whenever any file changes you can modify the 'autoWatch' option to 'true' and 'singleRun' option to 'false'. A coverage report is also available at: http://localhost:9876/ after you run: npm run coverage.
The default browser is Google Chrome.
Place your tests in the same location of the application source code files that they test, e.g. ending with *.component.spec.ts
and run: npm test
If you run into odd test errors, see the Angular guide to debugging tests: https://angular.io/guide/test-debugging
E2E tests (aka integration tests) use Cypress.io. Configuration for cypress can be found in the cypress.json file in the root directory.
The test files can be found in the ./cypress/e2e/ folder.
Before you can run e2e tests, two things are REQUIRED:
config.prod.yml or config.dev.yml has its rest settings defined to use that localhost backend.DSPACE_REST_SSL = false
DSPACE_REST_HOST = localhost
DSPACE_REST_PORT = 8080
psql -U dspace < dspace7-entities-data.sql). See instructions in link above.After performing the above setup, you can run the e2e tests using
ng e2e
NOTE: By default these tests will run against the REST API backend configured via environment variables or in config.prod.yml. If you'd rather it use config.dev.yml, just set the NODE_ENV environment variable like this:
NODE_ENV=development ng e2e
The ng e2e command will start Cypress and allow you to select the browser you wish to use, as well as whether you wish to run all tests or an individual test file. Once you click run on test(s), this opens the Cypress Test Runner to run your test(s) and show you the results.
All E2E tests must be created under the ./cypress/e2e/ folder, and must end in .spec.ts. Subfolders are allowed.
ng e2e. This builds the app and brings up Cypress.+ New Spec File. Choose a meaningful name ending in spec.ts (Please make sure it ends in .ts so that it's a Typescript file, and not plain Javascript)describe and it which just cy.visit the page you want to test. For example:
describe('Community/Collection Browse Page', () => {
it('should exist as a page', () => {
cy.visit('/community-list');
});
});
class and id in tests, as those are likely to change later on. Instead, you can add a data-test attribute to makes it clear that it's required for a test.click or type in an element that's not fully loaded yet, causing tests to fail.[attr.data-test]="'button' | ngBrowserOnly". This will only show the attribute in CSR HTML, forcing Cypress to wait until CSR is complete before interacting with the element.Hint: Creating e2e tests is easiest in an IDE (like Visual Studio), as it can help prompt/autocomplete your Cypress commands.
More Information: docs.cypress.io has great guides & documentation helping you learn more about writing/debugging e2e tests in Cypress.
See our DSpace Code Testing Guide for more hints/tips.
Official DSpace documentation is available in the DSpace wiki at https://wiki.lyrasis.org/display/DSDOC10x/
Some UI specific configuration documentation is also found in the ./docs folder of this codebase.
To build the code documentation we use TYPEDOC. TYPEDOC is a documentation generator for TypeScript projects. It extracts information from properly formatted comments that can be written within the code files. Follow the instructions here to know how to make those comments.
Run:npm run docs to produce the documentation that will be available in the 'doc' folder.
There are many more commands in the scripts section of package.json. Most of these are executed by one of the commands mentioned above.
A command with a name that starts with pre or post will be executed automatically before or after the script with the matching name. e.g. if you type npm run start the prestart script will run first, then the start script will trigger.
To get the most out of TypeScript, you'll need a TypeScript-aware editor. We've had good experiences using these editors:
See our Contributing guidelines for general tips on contributing back to DSpace.
For developers, we also provide guidelines for:
dspace-angular
├── config *
│ └── config.yml * Default app config
├── cypress * Folder for Cypress (https://cypress.io/) / e2e tests
│ ├── downloads * (Optional) Folder for files downloaded during e2e tests
│ ├── e2e * Folder for e2e/integration test files
│ ├── fixtures * Folder for reusable static test data (JSON, images, etc.)
│ ├── plugins * Folder for Cypress plugins (if any)
│ ├── support * Folder for global e2e test actions/commands (run for all tests)
│ └── tsconfig.json * TypeScript configuration file for e2e tests
├── docker * See docker/README.md for details
│ ├── cli.assetstore.yml *
│ ├── cli.ingest.yml *
│ ├── cli.yml *
│ ├── db.entities.yml *
│ ├── docker-compose-ci.yml *
│ ├── docker-compose-rest.yml *
│ ├── docker-compose.yml *
│ └── README.md *
├── docs * Folder for documentation
│ ├── Configuration.md * Configuration documentation
│ └── ThemeTranslations.md * Theme-specific translations documentation
├── scripts *
│ ├── merge-i18n-files.ts *
│ ├── serve.ts *
│ ├── sync-i18n-files.ts *
│ └── test-rest.ts *
├── src * The source of the application
│ ├── app * The source code of the application, subdivided by module/page.
│ ├── assets * Folder for static resources
│ │ ├── fonts * Folder for fonts
│ │ ├── i18n * Folder for i18n translations
│ │ └── images * Folder for images
│ ├── backend * Folder containing a mock of the REST API, hosted by the express server
│ ├── config *
│ ├── environments *
│ │ ├── environment.production.ts * Production configuration files
│ │ ├── environment.test.ts * Test configuration files
│ │ └── environment.ts * Default (development) configuration files
│ ├── mirador-viewer *
│ ├── modules *
│ ├── ngx-translate-loaders *
│ ├── styles * Folder containing global styles
│ ├── themes * Folder containing available themes
│ │ ├── custom * Template folder for creating a custom theme
│ │ └── dspace * Default 'dspace' theme
│ ├── index.csr.html * The index file for client side rendering fallback
│ ├── index.html * The index file
│ ├── main.browser.ts * The bootstrap file for the client
│ ├── main.server.ts * The express (http://expressjs.com/) config and bootstrap file for the server
│ ├── polyfills.ts *
│ ├── robots.txt * The robots.txt file
│ ├── test.ts *
│ └── typings.d.ts *
├── webpack *
│ ├── helpers.ts * Webpack helpers
│ ├── webpack.browser.ts * Webpack (https://webpack.github.io/) config for browser build
│ ├── webpack.common.ts * Webpack (https://webpack.github.io/) common build config
│ ├── webpack.mirador.config.ts * Webpack (https://webpack.github.io/) config for mirador config build
│ ├── webpack.prod.ts * Webpack (https://webpack.github.io/) config for prod build
│ └── webpack.test.ts * Webpack (https://webpack.github.io/) config for test build
├── angular.json * Angular CLI (https://angular.io/cli) configuration
├── cypress.json * Cypress Test (https://www.cypress.io/) configuration
├── Dockerfile *
├── karma.conf.js * Karma configuration file for Unit Test
├── LICENSE *
├── LICENSES_THIRD_PARTY *
├── package.json * This file describes the npm package for this project, its dependencies, scripts, etc.
├── package-lock.json * npm lockfile (https://docs.npmjs.com/cli/v10/configuring-npm/package-lock-json)
├── postcss.config.js * PostCSS (http://postcss.org/) configuration
├── README.md * This document
├── SECURITY.md *
├── server.ts * Angular Universal Node.js Express server
├── tsconfig.app.json * TypeScript config for browser (app)
├── tsconfig.json * TypeScript common config
├── tsconfig.server.json * TypeScript config for server
├── tsconfig.spec.json * TypeScript config for tests
├── tsconfig.ts-node.json * TypeScript config for using ts-node directly
├── tslint.json * TSLint (https://palantir.github.io/tslint/) configuration
└── typedoc.json * TYPEDOC configuration
This project makes use of npm to ensure that the exact same dependency versions are used every time you install it.
npm creates a package-lock.json to track those versions. That file is updated automatically by whenever dependencies are added/updated/removed via npm.npm install. For example: npm install some-lib.
devDependencies), use npm install some-lib --save--devnpm update. For example: npm update some-lib or npm update some-lib@versionnpm uninstall to remove it.As you can see above, using npm commandline tools means that you should never need to modify the package.json manually. We recommend always using npm to keep dependencies updated / in sync.
If the library does not include typings, you can install them using npm:
npm install d3 npm install @types/d3 --save-dev
If the library doesn't have typings available at @types/, you can still use it by manually adding typings for it:
In src/typings.d.ts, add the following code:
declare module 'typeless-package';
Then, in the component or file that uses the library, add the following code:
import * as typelessPackage from 'typeless-package'; typelessPackage.method();
Done. Note: you might need or find useful to define more typings for the library that you're trying to use.
If you're importing a module that uses CommonJS you need to import as
import * as _ from 'lodash';
@Injectable() for your service for typescript to correctly attach the metadatasrc/app/home/home.component.ts call it src/app/home/home.component.spec.tsEACCES and EADDRINUSE errors?
EADDRINUSE error means the port 4000 is currently being used and EACCES is lack of permission to build files to ./dist/git checkout --theirs package-lock.jsonnpm install again. NPM will create a new lockfile that contains both sets of changes.git add package-lock.json to stage the lockfile for commitgit commit to conclude the mergeDSpace provides public mailing lists where you can post questions or raise topics for discussion. We welcome everyone to participate in these lists:
Great Q&A is also available under the DSpace tag on Stackoverflow
Additional support options are at https://wiki.lyrasis.org/display/DSPACE/Support
DSpace also has an active service provider network. If you'd rather hire a service provider to install, upgrade, customize or host DSpace, then we recommend getting in touch with one of our Registered Service Providers.
DSpace uses GitHub to track issues:
DSpace source code is freely available under a standard BSD 3-Clause license. The full license is available in the LICENSE file or online at https://dspace.org/license/
DSpace uses third-party libraries which may be distributed under different licenses. Those licenses are listed in the LICENSES_THIRD_PARTY file.
DSpace/dspace-angular is a public repo on GitHub by DSpace. DSpace User Interface built on Angular.
It declares the BSD-3-Clause license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-17. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.

(Official) The DSpace digital asset management system that powers your Institutional Repository

(No longer actively maintained. Replaced by Docker compose in main codebase.) DSpace + Vagrant. Quickly spin up a virtual machine (via Vagrant) which is "DSpace development ready"
(OBSOLETE) XMLUI Language Packs (Multilingual Support / I18N) for DSpace 6.x and below
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/DSpace/dspace-angularTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.