How taigaio/taiga-front works
1. What this repo is
- This is the Taiga Front client: a single-page, browser-based project management UI.
- The app is built with AngularJS, authored mostly in CoffeeScript, with Jade/Pug templates and SCSS for styling.
2. Top-level runtime boundary
- The browser loads a small bootstrap layer in app-loader/, then the main application from app/.
- app/index.jade is the page shell; app-loader/bootstrap.coffee and app-loader/app-loader.coffee handle startup/loading concerns before the Angular app is fully active.
3. Core application composition
- app/coffee/app.coffee is the main app entry point that wires together the major Angular modules.
- The app is organized around feature modules, not a single monolith: each domain area has its own module, routes/controllers, and UI components.
4. Feature subsystems
- Major user-facing domains are split into dedicated modules under app/coffee/modules/ and app/modules/, including:
- auth: login, registration, password recovery
- home: landing/dashboard content
- projects: project creation, listing, transfer, imports, project detail
- backlog: sprint planning and user story backlog views
- kanban: board view and drag/drop workflow
- taskboard: task board and task movement
- issues / tasks / userstories / epics / wiki / team / profile / notifications / search
- admin: project administration, memberships, roles, values, integrations
- discover: public project discovery/search pages
5. UI building-block layer
- app/modules/components/ contains reusable widgets and directives shared across features.
- This layer includes lightboxes, filters, cards, attachments, avatars, tag controls, WYSIWYG editor wrappers, due date controls, board zoom, drag/drop helpers, and selection/search inputs.
- These are the main presentation primitives that feature modules compose into screens.
6. Service and resource boundary
- app/modules/resources/ and app/modules/services/ are the main non-visual layers.
- Resource services map directly to backend entities and API endpoints: projects, users, issues, tasks, epics, history, attachments, imports, stats, etc.
- Higher-level services handle cross-cutting client behavior such as current user state, permissions, theming, error handling, paging, avatar/logo handling, and activity tracking.
7. Backend integration
- The frontend depends on a separate backend API, documented in the README as Taiga API / taiga-back.
- Most feature flows are CRUD-like interactions through resource services, with the UI rendering server-backed domain models rather than keeping authoritative local state.
- The architecture is therefore client-driven presentation on top of a REST-ish API boundary.
8. State, navigation, and module organization
- Shared base utilities live in app/coffee/modules/base/ and establish common concerns like URLs, HTTP behavior, storage, repository/model helpers, filters, and navigation helpers.
- Feature modules typically depend on these shared primitives plus resource services.
- Navigation, route-specific controllers, and detail views are split by domain so the same entity type can appear in list, detail, board, and edit contexts.
9. Templates, partials, and styling
- app/partials/ holds reusable Jade snippets for screen composition, lightboxes, tables, and common UI fragments.
- app/styles/ is layered into core, dependencies, layout, modules, and vendor-specific styles, which mirrors the feature/module structure.
- This separation matters for architecture because most UI behavior is implemented as Angular directives/controllers, while layout and presentation are isolated in partials and SCSS.
10. Rich interaction patterns
- The app relies heavily on drag-and-drop, sortable lists, lightboxes, inline editing, popovers, and WYSIWYG content editing.
- These patterns appear across backlog, kanban, taskboard, epics, attachments, and wiki features, and are supported by shared components and custom JS helpers in app/js/.
11. Localization and content
- app/locales/taiga/ contains many JSON locale files, indicating multilingual UI rendering is a first-class concern.
- User-visible text is largely externalized, so internationalization is part of the app’s core presentation architecture.
- Emoji and markdown/rendering support are also included as static content helpers.
12. Testing and verification
- Unit tests are colocated with modules and services as *.spec.coffee, with Karma-based test configs at the root.
- End-to-end coverage lives under e2e/, with feature-focused suites mirroring the same domains as the app modules.
- This reflects the architectural split between isolated UI/service behavior and integrated browser flows against a running Taiga backend.
13. Build, packaging, and deployment
- gulpfile.js and related config files indicate a build pipeline that compiles CoffeeScript, templates, and styles into distributable assets.
- Docker files and conf/ templates show the app is designed to be served as a built frontend, with environment-specific configuration injected at runtime.
- The README also points to taiga-front-dist for compiled artifacts, reinforcing that this repo is the source tree, not the deployment bundle.
14. Diagram takeaway
- A good architecture diagram should show: browser entry → bootstrap/app shell → Angular feature modules → shared components/services/resources → Taiga backend API.
- Surrounding that core should be the static asset layer, localization, build/test tooling, and E2E verification path, since those materially shape how the frontend is developed and delivered.
Main entry points: app.coffee App entry · resources Resources · gulpfile.js Build & deploy · components UI components
Components 23
Runtime
Browser bootstrap and app shell
- Browser · User loads the frontend in the browser
- App loader · Startup and pre-Angular loading
app-loader - Page shell · Top-level HTML/Jade shell for the single-page app
app/index.jade
Core app
Angular composition and shared platform
- App entry · Main AngularJS app wiring
app/coffee/app.coffee - Base layer · Core URL, HTTP, model, storage, and navigation helpers
app/coffee/modules/base - Common layer · Cross-cutting client behavior and reusable utility services
app/coffee/modules/common - Resources · Entity resource services for backend endpoints
app/modules/resources - Client services · Higher-level client services for permissions, user state, theme, errors, and activity
app/modules/services - UI components · Reusable directives, controllers, and lightbox/UI primitives
app/modules/components
Features
User-facing domain modules
- Auth · Login, registration, invitations, and recovery
app/coffee/modules/auth.coffee - Home · Landing and working-on views
app/modules/home - Projects · Project create, listing, transfer, import, and detail flows
app/modules/projects - Planning · Backlog, kanban, taskboard, and sprint planning
app/coffee/modules/backlog.coffee - Work items · Issues, tasks, user stories, and epics detail surfaces
app/coffee/modules/issues.coffee - Collaboration · Team, profile, notifications, search, and wiki areas
app/coffee/modules/team.coffee - Admin · Project administration, memberships, roles, values, and integrations
app/coffee/modules/admin.coffee - Discover · Public project discovery and search pages
app/modules/discover
Assets
Templates, styles, locales, and static helpers
- Templates & styles · Reusable Jade partials, SCSS layers, and static UI assets
app/partials - Locales · Translated UI strings and language packs
app/locales/taiga - JS helpers · Vendor and custom browser-side helpers used by the app
app/js
Tooling
Build, tests, and deployment
- E2E suites · Feature-oriented end-to-end browser tests
e2e - Build & deploy · Gulp, Karma, Docker, and config for packaging the frontend
gulpfile.js
Other components
- Taiga API · Separate REST API backend consumed by the frontend
Connections 31
- Browser → App loader: loads · Browser begins with the bootstrap layer
- App loader → Page shell: mounts · Loader brings up the page shell
- Page shell → App entry: hosts · Shell contains the Angular application entry
- App entry → Base layer: wires · App entry composes shared foundation modules
- App entry → Common layer: wires · App entry composes common cross-cutting modules
- App entry → Resources: uses · Feature flows are backed by resource services
- App entry → Client services: uses · App-wide behaviors come from client services
- App entry → UI components: composes · Features build screens from reusable UI components
- App entry → Auth: includes · Auth is one of the major routed feature areas
- App entry → Home: includes · Home is one of the major routed feature areas
- App entry → Projects: includes · Projects is one of the major routed feature areas
- App entry → Planning: includes · Planning modules drive backlog and boards
- App entry → Work items: includes · Work item detail and list modules are core features
- App entry → Collaboration: includes · Collaboration modules cover profile, team, search, wiki, and notifications
- App entry → Admin: includes · Admin routes and screens are wired from the app entry
- App entry → Discover: includes · Public discovery pages are part of the app surface
- UI components → Templates & styles: renders with · Shared widgets are backed by templates and styles
- UI components → JS helpers: extends · Components rely on custom browser helpers
- Auth → Resources: reads/writes · Auth flows talk to backend resources
- Projects → Resources: reads/writes · Project flows depend on project and import resources
- Planning → Resources: reads/writes · Boards and backlog use sprint, issue, and task resources
- Work items → Resources: reads/writes · Issue, task, story, and epic screens load server entities
- Collaboration → Resources: reads/writes · Profile, notifications, search, and wiki use backend data
- Admin → Resources: reads/writes · Admin pages manipulate project settings and memberships through resources
- Discover → Resources: reads/writes · Discovery views query public project data
- Resources → Taiga API: calls · Resources are the REST boundary to Taiga backend
- Client services → Taiga API: calls · Client services also wrap backend interactions
- E2E suites → Browser: verifies · End-to-end suites exercise the browser app
- Build & deploy → App loader: packages · Build pipeline compiles bootstrap and app assets
- Build & deploy → Templates & styles: compiles · Templates and styles are bundled into distributable assets
- Build & deploy → Locales: bundles · Translation files are included in the build