Two branches · one project space

Simulate it.
Train it.Understand it.

Nova is a home for low-level engine work and hands-on AI experimentation: Nova_A builds a 2D engine/editor stack in C++20; Nova_v1 explores LLM training and chat in Python.

Nova_A
engine from scratch.

The public repository describes Nova_A as a fully open-source 2D physics engine, renderer and GUI editor built from scratch with C++20. Its current public README documents OpenGL/GLAD initialization, GLFW windowing, ImGui editor integration and a rendering abstraction.

Current foundation

Rendering + editor.

  • C++20 codebase with CMake build configuration
  • OpenGL context and GLAD loading
  • GLFW window creation and application loop
  • ImGui integration for the editor GUI
  • Renderer abstraction for clear rendering responsibilities
Road ahead

Build the engine.

01Shader pipeline and basic triangle rendering.
02Sprite batching and texture loading.
03Minimal physics core.
04Editor gizmos, scene graph and asset pipeline.
Engine work makes abstractions visible. Windowing, rendering, state, tooling and physics become systems you can inspect instead of black boxes you only call.

Nova_v1
LLM, hands on.

Nova_v1 is described by its repository as a simple LLM training and chat application based on Python. This page intentionally keeps the description conservative and points to the repository for the exact implementation and current capabilities.

Training

See the pipeline.

Keep the training workflow understandable: inputs, configuration, model state and outputs should remain inspectable rather than hidden behind an opaque service.

PythonLLM trainingExperimentation
Chat

Use what you build.

A chat surface closes the loop between model work and direct interaction, making it easier to test behavior and iterate on training experiments.

One principle.
Learn by building.

Nova_A works downward toward graphics, physics and editor primitives. Nova_v1 works upward toward model training and interaction. Both are useful because the implementation remains close enough to inspect, change and learn from.

Inspect

Know the layers.

Prefer explicit systems and readable boundaries over hidden behavior.

Iterate

Ship small steps.

Keep versions testable so every change can be verified and rolled back.

Open

Keep the code visible.

Use the repositories as the source of truth for implementation details and progress.