# mirego/accent: Self-Hosted Translation Management for Elixir Teams

> mirego/accent is an open source translation management system for web and native applications, with a Phoenix web interface, GraphQL API, CLI, history, and rollback support. It is aimed at teams that want translators to collaborate with developers without managing translation files through a manual handoff.

**mirego/accent** — The first developer-oriented translation tool. True asynchronous flow between translators and your team.

- Repository: https://github.com/mirego/accent
- Website: https://www.accent.reviews
- Stars: 1,494 · Forks: 120
- Language: TypeScript
- License: BSD-3-Clause
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/mirego-accent

## Why Accent separates translation work from application delivery

Accent addresses the coordination problem around maintaining translations in a web or native application. The README describes it as a developer-oriented translation tool whose main model is an asynchronous flow between translators and the development team. Instead of treating localization as a collection of files exchanged through commits or spreadsheets, Accent centralizes the work and gives the application team an API and interface for managing it.

The intended users are teams that have both developers and translators, especially applications with an Elixir or Phoenix connection. The repository topics include `elixir`, `elixir-phoenix`, `emberjs`, `absinthe`, and `graphql`, which are consistent with that orientation, although the README does not limit the supported application stack to those examples. The web interface is intended for collaboration, while the CLI can fit Accent into a developer workflow. A GraphQL API supports plugins, command-line tools, or libraries.

The main design choice is server-side persistence. Accent uses PostgreSQL as its only external dependency for the Docker quickstart. That makes translation data a shared application concern rather than a set of files owned by one person. It also means an adopter needs to make operational decisions about the database, session management, authentication, backups, and deployment.

## The GraphQL and database model behind Accent

Accent is built as a Phoenix application with a GraphQL API that powers its user interface. The README states that the API is open and documented, so integrations do not have to depend exclusively on the browser interface. The repository includes `lib/`, `webapp/`, and `cli/` directories, indicating a server component, web client, and command-line component.

The documented feature set includes translation history, actions such as rollback, a translation-oriented UI, centralized discussions, and the GraphQL API. History records who changed what and when, according to the README. Rollback is presented as an available action over that history. The exact GraphQL schema is not included in the README excerpt or repository files shown here, so the precise mutation names, query fields, authorization rules, and pagination behavior cannot be confirmed.

The database is initialized as part of starting the Docker image, according to the getting-started instructions. The quickstart also requires a `SECRET_KEY_BASE` for session management. This is important for deployment planning because the application is not just a static translation editor. It runs migrations, starts a web server, and depends on environment-based configuration, following the Twelve-Factor App pattern described in the README.

## Running Accent with PostgreSQL and Docker

The shortest documented path uses the official `mirego/accent` Docker image. The application expects a PostgreSQL database, and the README describes port `4000` as the web server port. Create a local `.env` file with the following values, changing the database host if PostgreSQL is not available at `docker.for.mac.host.internal`.

```bash
DATABASE_URL=postgresql://postgres@docker.for.mac.host.internal/accent_development
DUMMY_LOGIN_ENABLED=1
SECRET_KEY_BASE=KEY
```

The README says `SECRET_KEY_BASE` must be a 64-byte string and gives this command for generating one:

```bash
openssl rand -hex 64
```

Start the image with the environment file and publish the application port:

```bash
docker run --env-file .env -p 4000:4000 mirego/accent
```

According to the README, this starts the web server and migrates the database. The expected first result is an Accent instance available on port `4000`. The dummy login option is intended for a simple local setup. The README does not describe the login flow in detail, so production authentication and third-party login configuration should be checked before exposing the service.

## A Phoenix development setup with make and mix

For local development, the README lists Erlang, Elixir, PostgreSQL, and Node.js as requirements. The documented versions are `erlang ~> 26.1`, `elixir ~> 1.15`, `postgres >= 9.4`, and `node.js >= 16.19`. The root `package.json` declares Node.js `>= 16.13.0`, while the Dockerfile uses newer Node.js images for its build stages. The README is the source for the supported runtime list.

The development sequence starts by installing dependencies through the Makefile. This target installs the Mix, root npm, webapp npm, CLI npm, and Jipt dependencies. It then creates the database and starts the Phoenix endpoint.

```bash
make dependencies
mix ecto.setup
mix phx.server
```

The README says the app should then be available at `http://localhost:4000`. If PostgreSQL uses the default local setup, Accent can rely on its default configuration, but commands run with a non-default database or environment should load the required variables. The README gives the following pattern when using `nv`:

```bash
nv .env mix <mix command>
```

The Makefile also provides Docker targets, including `make build`, `make dev-start-postgresql`, and `make dev-start-application`. The Docker Compose file uses `postgres:15.6`, exposes PostgreSQL on `5432`, and sets the application database URL to `postgres://postgres@localhost:5432/accent_development`. The Makefile also groups common tasks for tests, linting, Docker, npm, Prettier, and Stylelint, which reduces the need to learn separate command locations.

## CLI integration and the boundary of Accent's workflow

The separate `cli/` directory and README reference indicate that Accent is intended to fit into a development workflow rather than operate only through a browser. The README does not give installation, authentication, or usage commands for the CLI. Consequently, the exact process for registering an application, uploading strings, downloading translations, or authenticating cannot be documented without inventing flags or configuration keys.

The collaboration model is also server-centered. Translators can work through the UI, while the GraphQL API exposes the application layer to extensions. That approach can reduce manual coordination, but it introduces operational responsibilities that a local library does not. Operators must keep Accent reachable, manage PostgreSQL, configure session security, and decide how authentication is connected to their organization. The README mentions third-party logins and dummy login support, but its environment-variable section is truncated after the `PORT` row, so their complete configuration is not available in the repository excerpt.

Accent is therefore a poor fit for a small project that only needs a JSON translation helper, compile-time extraction, or a few static locale files. The README does not show such a library API. The practical alternative is a local translation format stored with application source, such as JSON or another application-specific locale structure, with developers reviewing changes through version control. The difference is architectural: Accent adds a hosted collaboration service, persistent history, rollback, and API access, while a local format avoids a separate server but leaves coordination and history to the repository workflow.

## Docker deployment, maintenance, and license considerations

The Docker image is the most self-contained route for running the application, while the source setup requires several runtimes and build tools. The repository is not archived, and the last push was on 2026-10-16. That indicates recent repository activity, but it does not establish a release cadence or guarantee compatibility for a particular deployment. The repository has no GitHub releases according to the repository release information, so there is no documented release-based upgrade path in the README. The CHANGELOG.md file exists, but its contents are not provided.

Accent is licensed under BSD-3-Clause. The license permits use and modification subject to its conditions, but this review does not provide legal advice. Operators should read `LICENSE.md` for the applicable copyright and notice requirements, especially when redistributing modified builds or embedding the software in a commercial deployment.

The application migrates the database during startup, according to the Docker getting-started instructions. That behavior reduces the number of manual setup steps, but the README does not document backup, downgrade, migration rollback, or schema compatibility procedures. A deployment should therefore be treated as a database-backed service rather than a disposable container. Changing the PostgreSQL connection, session secret, authentication mode, or port also affects production behavior, and the operator should keep those environment settings separate from local development values.

## Conclusion

Adopt mirego/accent when a team needs a shared, asynchronous translation workflow and is prepared to operate PostgreSQL and an Accent instance. Do not choose it if you only need a lightweight client-side translation library. Verify first that the documented runtime versions, authentication settings, and CLI integration match your application.

## FAQ

### What does mirego/accent do?

Accent provides a shared system for maintaining translations in web and native applications. Its documented features include a translation UI, history, rollback, collaboration, a CLI, and a GraphQL API.

### How do I run mirego/accent locally?

The README documents a Docker quickstart using PostgreSQL and the official `mirego/accent` image. It also documents a Phoenix setup using `make dependencies`, `mix ecto.setup`, and `mix phx.server`.

### Which databases and runtimes does mirego/accent require?

The documented external dependency is PostgreSQL. The README lists `erlang ~> 26.1`, `elixir ~> 1.15`, `postgres >= 9.4`, and `node.js >= 16.19` as requirements for the full development stack.

## Sources

- [Issues](https://github.com/mirego/accent/issues)
- [License: BSD-3-Clause](https://github.com/mirego/accent/blob/master/LICENSE)
- [mirego/accent on GitHub](https://github.com/mirego/accent)
- [Project website](https://www.accent.reviews)
- [README](https://github.com/mirego/accent/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mirego-accent