Orbit

A modular Python framework and tooling ecosystem focused on modern developer infrastructure, fullstack orchestration, and experimental architecture.

Open-source project under Undreamt focused on building developer-first tooling and framework utilities in Python.

Orbit is a modular fullstack framework ecosystem designed for:

• Data-driven applications
• APIs and services
• Backend platforms
• Fullstack orchestration
• Developer tooling
• Experimental infrastructure

The ecosystem is built around a simple idea:

Frameworks should be modular, understandable, type-safe, and easy to extend — without becoming bloated or overly abstract.

Orbit focuses on orchestration and architecture rather than reinventing every layer of the stack.

Orbit aims to explore modern framework architecture while keeping the ecosystem lightweight, learnable, and flexible.

Instead of building a single monolithic framework, Orbit focuses on creating independent modules that work well together while remaining usable on their own.

The long-term goal is to create a composable fullstack platform for services and data-driven systems with:

• Modular architecture
• Typed contracts
• Backend/frontend orchestration
• Scalable runtime systems
• Service-oriented workflows

Current Orbit ecosystem:

                ┌─────────────────┐
                │   orbit-cli     │
                │ scaffolding/DX  │
                └────────┬────────┘
                         │
                         ▼
              orbit new app
                         │
         ┌───────────────┴────────────────┐
         ▼                                ▼
┌─────────────────┐             ┌─────────────────┐
│     backend     │             │    frontend     │
│ FastAPI/Robyn   │             │ Vue/Nuxt/etc    │
└────────┬────────┘             └────────┬────────┘
         │                               │
         ▼                               ▼
 ┌──────────────┐               ┌────────────────┐
 │ orbit-server │               │ frontend stack │
 │ runtime layer│               │ vite/nuxt/etc  │
 └──────────────┘               └────────────────┘
         │
         ▼
 ┌──────────────┐
 │ orbit-core   │
 │ framework    │
 │ primitives   │
 └──────────────┘
         │
         ▼
 ┌──────────────┐
 │ orbit-types  │
 │ shared types │
 └──────────────┘

Orbit is being built with strong focus on:

• Modular design
• Clean architecture
• Strong typing
• Developer experience
• Learnable internals
• Extensibility
• Public experimentation
• Real-world implementation

Orbit intentionally delegates specialized problems to specialized ecosystems instead of replacing everything internally.

Current ecosystem integrations include:

• FastAPI
• Robyn
• Vue
• Nuxt
• Vite
• Quasar

app/
├── backend/
│   ├── api/
│   │   ├── routes/
│   │   ├── controllers/
│   │   └── services/
│   │
│   ├── core/
│   ├── models/
│   ├── main.py
│   └── requirements.txt
│
├── frontend/
│   ├── app/
│   ├── package.json
│   ├── vite.config.ts
│   └── ...
│
├── env/
├── orbit.config.py
└── README.md

Orbit currently structures backend applications into layered components.

Responsible for:

• Endpoint definitions
• HTTP mapping
• Request entrypoints

@app.get("/users")

Responsible for:

• Request handling
• Orchestration
• Calling services

Responsible for:

• Business logic
• Data processing
• Reusable backend logic

Responsible for:

• Data structures
• Schemas
• ORM entities later

Responsible for:

• Config
• Responses
• Shared backend utilities

Orbit currently supports integration with:

Orbit delegates frontend runtime responsibilities to existing frontend ecosystems instead of reinventing frontend rendering internally.

orbit start

Starts:

• FastAPI server
• or Robyn runtime

orbit dev

Starts:

• Vite/Nuxt frontend development server

orbit runserver

Starts:

• Backend server
• Frontend development server

simultaneously.

orbit build

Runs frontend production builds.

orbit serve

Runs frontend preview/runtime commands.

Orbit CLI is built using:

• Typer

Current commands:

orbit new
orbit start
orbit dev
orbit runserver
orbit build
orbit serve

orbit new app

Current generation flow:

1. Select backend
2. Select frontend
3. Select JS/TS
4. Create project structure
5. Create environment
6. Install dependencies
7. Generate templates

Orbit creates isolated Python environments using:

python -m venv env

Used for:

• Backend dependencies
• Orbit packages
• Isolated development

Example config:

CONFIG = {
    "backend": {
        "framework": "fastapi",
        "entry": "main:app"
    },

    "frontend": "vue"
}

Acts as:

• Runtime contract
• Framework metadata
• Orchestration configuration

Orbit modules are published individually to PyPI:

• orbit-framework-core
• orbit-framework-server
• orbit-framework-cli
• orbit-framework-types
• orbit-framework-kit

pip install orbit-framework-kit

orbit-kit
    ├── orbit-core
    ├── orbit-server
    ├── orbit-cli
    └── orbit-types

Orbit is currently optimized for:

• APIs
• Services
• Data-driven applications
• SaaS-like systems
• Backend platforms
• Fullstack orchestration

Orbit is not primarily focused on:

• Traditional MVC websites
• CMS-style platforms
• Monolithic rendering systems

Orbit is currently in an early framework platform phase.

Current status:

• Foundations exist
• Runtime works
• Architecture direction established
• Ecosystem operational

Still evolving:

• Abstractions
• Service layer
• Middleware systems
• Plugin architecture
• Data layer
• Runtime systems

Orbit is being built publicly and contributions, experiments, discussions, and feedback are always welcome.

Ways to contribute:

• Improve architecture
• Report issues
• Suggest ideas
• Improve documentation
• Create tooling experiments
• Help with testing
• Contribute utilities/modules
• Improve developer workflows

Orbit has learned from and experimented around ideas inspired by projects and tools across the Python ecosystem and frontend ecosystem, including:

• FastAPI
• Robyn
• Typer
• Click
• Pydantic
• Starlette
• Rich
• Uvicorn
• Vue.js
• Vite
• Nuxt
• Quasar

Thanks to the open-source community and all the projects that continue to inspire experimentation, learning, and better developer tooling.