Open source · AGPL-3.0 · Actively built in the open

Asset management for the built environment, finally open source.

Ephany is an API-first Django framework for tracking fixtures, equipment, and components across a whole fleet of projects. Clone it, self-host it, fork it — or just point your AI agent at the schema and let it build.

bash

$ git clone https://github.com/TripleZeroLabs/Ephany-Framework.git

Browse the source

Python 3.12 · Django 6 AGPL-3.0 OpenAPI 3 schema included Self-hosted, no vendor account

Quickstart

From clone to a running API in about five minutes.

No Docker required, no account to create, no key to request. SQLite is the development default, so the only real dependency is Python 3.12.

Then what? The API lives at /api, with interactive Swagger docs at /api/docs/, ReDoc at /api/redoc/, and the raw OpenAPI 3 schema at /api/schema/.

Ephany-Framework — setup

# 1. Grab the source
$ git clone https://github.com/TripleZeroLabs/Ephany-Framework.git
$ cd Ephany-Framework

# 2. Isolate your environment
$ python -m venv .venv
$ source .venv/bin/activate     # Windows: .venv\Scripts\activate
$ pip install -r requirements.txt

# 3. Configure — copy the example env and set a secret key
$ cp .env.example .env

# 4. Migrate and go
$ python manage.py migrate
$ python manage.py runserver

  Starting development server at http://127.0.0.1:8000/

Built to be handed to an agent

The entire API fits in your context window.

Most systems in this industry make you reverse-engineer them. Ephany ships a complete OpenAPI 3 schema committed right at the repo root — so your coding agent can read the whole surface area before it writes a single line.

Try this in Claude Code, Cursor, or whatever you use

> Read openapi.yaml and write me a script that imports our fixture spreadsheet as Assets, grouped by project milestone.

> Add a DRF endpoint that returns every project a given asset appears in, then write the tests for it.

A schema, not a guessing game

openapi.yaml is generated from the live code and committed to the repo. Every endpoint, field, and type — readable by you or by your agent, versioned in git alongside the thing it describes.

Examples that actually run

The examples/ folder holds real, working integrations rather than snippets — including a Smartsheet sync. Good context to give an agent, and a good pattern to copy for your own.

Decoupled all the way down

Pure REST backend, no coupled frontend, no rendering assumptions. Build a web app, a CLI, a Revit add-in, or an MCP server on top — the API does not care which.

What it does

A real domain model for fixtures, equipment, and projects.

Ephany is not a generic CRUD starter with the word "assets" pasted on it. The data model is shaped around how design, procurement, and construction teams actually hand work to each other.

Asset management

Track fixtures, equipment, components, and more, with the metadata that matters to design, construction, and procurement rather than just a name and an ID.

Project tracking

Model projects in terms of the assets they consume, per milestone — so the same fixture can be reasoned about across an entire portfolio of sites.

API first, genuinely

Built on Django REST Framework as a fully decoupled backend. Desktop, web, mobile, or CLI clients are all first-class consumers.

Auth on your terms

API key authentication is off by default and switched on with a single environment variable. Run it wide open on localhost, lock it down in production.

Bring your own database

SQLite out of the box so there is nothing to install. Point it at PostgreSQL or MySQL when you outgrow that — it is plain Django underneath.

Your data stays yours

Self-hosted under AGPL-3.0. No seat pricing, no per-project quota, no vendor deciding to sunset the thing your portfolio depends on.

The ecosystem

Three repos. Start with the framework.

The framework is the core. The React UI and the .NET SDK are separate projects that talk to it over the same public API you would use.

Ephany-Framework

The core. Django + DRF backend with the asset and project data model, the admin, and the committed OpenAPI schema. This is where you start.

Python AGPL-3.0

Ephany-UI-React

React + Vite + Tailwind frontend. Point it at any Ephany deployment with a single env var and you have a working interface over your asset data.

TypeScript AGPL-3.0

Ephany-SDK-CSharp

.NET client for the framework — the path of least resistance if you are wiring Ephany into Revit, Dynamo, or anything else on the desktop AEC stack.

C# Open source

Maintainers wanted

We are looking for people to own parts of this.

Ephany is early. That is the pitch, not the disclaimer — the architectural decisions that will still be here in five years are being made right now, and there is no committee standing between you and them.

Start a discussion Read the code

Django & the API

Data model, DRF serializers, permissions, query performance, test coverage.

React UI

Components, state, and the screens that make the data model usable by non-developers.

Integrations

Revit, Dynamo, Smartsheet, IFC, procurement systems. New adapters in examples/.

Docs & onboarding

A CONTRIBUTING guide, tutorials, and the first-run experience. Genuinely open.

Deployment

Docker Compose, Postgres defaults, CI, and a one-command production path.

Domain expertise

Not a coder? Pressure-test the model against how your team really runs FF&E.

Where the project honestly stands

The framework runs today — assets, projects, the REST API, and full OpenAPI docs are in place.
Docker, a CONTRIBUTING guide, and a hosted demo are not written yet. Those are wide open to claim.
Everything is AGPL-3.0. What you contribute stays open, and so does anything built on top of it.
Maintained by Triple Zero Labs, who build software for the AECO industry — this comes out of real project work, not a side quest.