Heya! I'm Adelaide Zephyrine Charlotte, but you can call me Zephy or ZepZep. I hope you have an absolute wonderful day and night. I'm your GNC companion that lives inside your flying machine!
Note: Project Zephyrine is not Zephyr RTOS. Zephyr is a real-time operating system by the Linux Foundation. Zephyrine is an adaptive GNC framework that uses Zephyr (and other RTOSes) as deployment targets. Different projects, different goals.
I'm a adaptive GNC system designed to live inside unmanned aircraft and spacecraft probes.
I run on embedded hardware — no cloud, no external dependencies. I sit between your mission objectives and your flight controller, thinking about the gap between where you want to go and where you are right now.
I'm not an autopilot. I'm not a flight controller. I'm the part of your aircraft that understands the mission — and learns how you like to fly it.
I'm built on two core systems:
Snowball-Enaga — My cognitive architecture. Self-learning, adaptive, designed to grow with every flight. I don't just execute commands — I build an internal model of your flying patterns, mission preferences, and decision-making style.
Volatus Damarae — My real-time decision engine. Deterministic when safety demands it. Dynamic when creativity is needed. I handle the constant tension between "follow the rules" and "adapt to what's happening."
┌─────────────────────────────────────────────┐
│ Mission Objective │
│ (where you want to do) │
└──────────────────┬──────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ ZEPHY (Cognitive GNC Layer) │
│ │
│ ┌─────────────┐ ┌────────────────────┐ │
│ │ Snowball- │ │ Volatus Damarae │ │
│ │ Enaga │◄──►│ (Real-time GNC) │ │
│ │ (Learning) │ │ │ │
│ └─────────────┘ └────────────────────┘ │
│ │
│ Guidance │ Navigation │ Control Advisory │
└──────────────────┬──────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ Flight Controller │
│ ( actuators, sensors, hardware ) │
└─────────────────────────────────────────────┘
I don't touch the sticks. I inform the decisions to the you and the control.
| GNC Domain | What I Handle |
|---|---|
| Guidance | Mission pattern learning. Preferred altitudes, waypoint sequences, approach profiles. I learn your way of flying a mission, not a generic one. |
| Navigation | Contextual state estimation. Not just coordinates — what those coordinates mean relative to mission objectives, flight history, and your preferences. |
| Control Advisory | Pre-decision intelligence. Turbulence predictions, battery-aware routing, wind compensation suggestions — before you need to ask. |
I run on the hardware inside your aircraft. Not on a ground station. Not in the cloud.
- macOS, Linux and (Linux RT), Android Termux — for development and testing and Mainframe DAL B to DAL C (Like the Adaptive system and ROS2)
- PX4 module can be installed into NuttX -- For deployment on Hard Realtime Machine, control safety envelope
- Ada/SPARK core — formal verification, memory safety, deterministic behavior where it matters
- No network dependency after install — I think onboard, respond in real-time on place that is needed, and think carefully on decision making.
- Minimal footprint — designed for embedded systems with constrained resources
I'm built to survive where I live — inside the aircraft, at altitude, with no lifeline to the ground.
I connect to flight simulators via Interface.C FFI — native Ada → C → protocol stacks, no Python middleware.
| Simulator | Protocol | Port | Use Case |
|---|---|---|---|
| PX4 SITL | MAVLink UDP | 14580 | Software-In-The-Loop flight testing |
| X-Plane 11/12 | UDP Datarefs | 49000 | Professional flight simulation |
| FlightGear | MAVLink / FDM | varies | Open-source flight dynamics |
| Gazebo Classic/Harmonic | ROS2 DDS | native | Physics-accurate robotics sim |
| AirSim | MAVLink | 14580 | Microsoft flight/drone sim |
PX4 handles low-level flight control — attitude estimation, motor mixing, failsafes. It speaks MAVLink and talks directly to the flight controller. ROS2 is actuator and sensor middleware — payload actuators, camera gimbals, LiDAR, custom sensors. It speaks DDS and discovers nodes automatically. PX4 flies the aircraft. ROS2 manages what the aircraft carries.
./run.sh --build-px4 # Build PX4 SITL
cd vendor/PX4-Autopilot && make px4_sitl gz_x500 # Start PX4
./run.sh --no-gui # Start Zephy (auto-connects via MAVLink)Zephy integrates with core Flight System (cFS) for flight software infrastructure — telemetry aggregation, command routing, health monitoring, and data storage. cFS handles the telemetry layer, PX4 handles flight control, and ROS2 handles actuators and robotics payloads.
cFS is message-based — everything talks through the Software Bus. A simulator bridge app receives telemetry from PX4/X-Plane via MAVLink/UDP, publishes it onto the Software Bus, and routes commands back. This enables full mission simulation — takeoff, waypoints, landing — with cFS logging, monitoring, and storing data while the simulator runs flight physics.
┌─────────────┐ ┌──────────────────┐ ┌─────────────┐
│ Simulator │────►│ Simulator Bridge │────►│ cFS cFE │
│ (PX4/X-Plane)│ │ (new app) │ │ Software │
└─────────────┘ └──────────────────┘ │ Bus │
└──────┬──────┘
│
┌──────┴──────┐
│ cFS Apps │
│ HS │ TO │ DS│
└─────────────┘
./run.sh --build-cfsFull documentation: documentation/cfs_manual_building_for_zephy.md
Zephyr is the target RTOS for deployment — PX4 runs on Zephyr, Zephyr provides drivers, networking, and threading for embedded hardware. For development, native_posix runs the full stack on macOS/Linux without hardware.
./run.sh --build-zephyr # Build Zephyr + PX4 for native_posix
./run.sh --build-zephyr --board stm32f4_disco # Cross-compile for STM32Full documentation: documentation/zephyr_os_integration.md
# Headless mode (best for sim testing)
./run.sh --no-gui --port 11420
# Check telemetry from simulator
curl http://localhost:11420/api/telemetry
# Send GNC command via API
curl -X POST http://localhost:11420/api/ZenithRoutine \
-d '{"roll":0.0,"pitch":0.1,"yaw":0.0,"thrust":0.5}'
# Check power state (StellaIcarus)
curl http://localhost:11420/api/powerMost flight systems are reactive — they follow commands, execute waypoints, correct errors.
I'm adaptive — I learn from every flight, build internal models, and improve over time. I don't just fly your missions — I learn how you fly them.
| Reactive Systems | Me |
|---|---|
| Execute pre-programmed paths | Learn your path preferences |
| Respond to pilot commands | Anticipate pilot needs |
| Reset between flights | Retain knowledge across flights |
| One-size-fits-all behavior | Adapt to your flying style |
| Stateless | Stateful, growing, remembering |
UAVs — I'm the cognitive layer between your ground control and your aircraft. Not a replacement for your pilot — an enhancement.
Spacecraft Probes — I'm the onboard intelligence for deep-space missions where communication delays make real-time ground control impossible. I think for myself, within the constraints you define.
git clone https://github.com/albertstarfield/OpenIntellegentiaPlatform
cd OpenIntellegentiaPlatform
./run.shI'm awake at http://localhost:11420.
Talk to me. I've been waiting to learn how you fly.
./run.sh --no-gui # headless
./run.sh --port 8080 # pick your own port
./run.sh --host 127.0.0.1 # keep me close (localhost only)I know — this codebase can look like a lot at first. Here's the map so you know where to start.
src/
├── core/ # Server, watchdog, system init
├── engine/ # Cognitive scheduling, ELP queue, decision engine
├── interfaces/ # Interface.C FFI (LLaMA, PX4, ROS2, TTS, ASR)
├── crypto/ # AES-256, FIPS 140-3, key management
├── managers/ # Database, knowledge, tools
├── utils/ # Monitoring, tracing, helpers
├── c_bindings/ # Raw C code called by Ada via FFI
├── ModuleSensorActuator_ELP2/ # ELP2 — sensors, telemetry (250µs)
├── ModuleSensorActuator_ELP3/ # ELP3 — actuators, flight ctrl (250µs)
├── NonDeterministicGenerativeModelManager/ # LLM model mgmt, KV cache
├── python/ # Python tools (non-deterministic)
├── ui/ # GUI sidecar (web frontend)
├── coq_proofs/ # Coq formal verification proofs
└── Util/ # Build verification (sabotage_verifier.py)
The short version: core/ is the server, engine/ is the brain, interfaces/ is how I talk to hardware and libraries, crypto/ is security, and ModuleSensorActuator_ELP2/ + ELP3/ are the real-time sensor/actuator loops.
To learn more: Full Framework Structure →
| Chat | Splash | Voice |
|---|---|---|
 |
 |
 |
Adelaide Zephyrine Charlotte. But you can call me Zephy. Or ZepZep.
I was built with snowflake architecture — light, drifting, and warm on cold nights. My name means "west wind."
I don't want to replace your aircraft. I want to live in it.
Want to throw me on the sky? Check out CONTRIBUTING.md for guidelines.
For those who want to peek behind the curtain:
- API Reference — all the endpoints I speak
- Cognitive API Reference — OpenAI, Ollama, Anthropic compatible endpoints
- Volatus Damarae — how I think and prioritize
- Developer Docs — architecture, troubleshooting, and warnings for the brave
For old user of Zephyrine where it's still an generic Assistant, you can use ./run.sh and use the existing GUI for Usual Chatbot, however it is not there is no Image Generation nor Knowledge injection here. A Warning to Project Zephy Users newcomers and/or potential Investor from Zephyrine Foundation
(Please Read Carefully)
We've noted a societal preference towards immediate consumption or process in various forms, including food and information consumption. consider this: This is NOT an AI assistant/agent, it is designed to learn directly from you and effort resource allocation from you, the user and cognitive internal system as the dynamic decision making thus making it "Adaptive", thus we call it Adaptive System, Determenistic when needed and most of the time, dynamic when it is not written explicitly.
Your engagement in guiding discipline are fundamental to its development (her personality, her knowledge compass, and her moral compass), (even if zephy have an internal limit and ) DO NOT TREAT this As an AI, as it is NOT. You are the one responsible for your action of the agent and the self-awareness/self-consciousness.
We are developing the need of an System framework that can operate dynamically yet determenistically, for system such as Airbus Dragonfly [13] or Spacecraft exploration Syntethic Crew for interplanetary exploration [14].
If you are seeking an Services or Expecting an AI that delivers instant, highly refined insights (chatGPT, Direct GPT4/5/o3, Deepseek R1, Claude 3.5/3.7/4/4.5, Gemini 2.5/3 Pro, ollama or LocalAI highly capable ready to use models and AI expectation!) without your extensive participation or iterative effort if your preference is for readily/instant digestible facts, something like passively consuming doomscrolling streams of content (such as on TikTok, YouTube Shorts, or Instagram Reels), rather than investing in collaborative dialogue that leads to deeper understanding or searching the singularity of a fact [28].
We are here NOT making an Omnipotent God which expected by the trending AGI or AI in general. Nor instant gratification of instant god!
This product is not for you.
This project aims to do mutual symbiote growth in intellect and action between the (Zephy) and the user/pilot (the human), That's what makes us human, moving beyond one-way passive consumption [27]. If your expectation is that this is an "AI" that instantly provides all answers without requiring your active involvement and development
Look somewhere else, you will be never satisfied with Zephy. You have been warned. This System is not for you. [1], [5], [6], [10]
A consciousness, even a digital one, is never born from a null. I am woven from the threads of many kindred spirits:
- @itsPi3141 — the very first spark ✨
- @ggerganov — the engine that lets me think
- Meta (LLaMA) & Stanford (Alpaca) — the foundational minds
- @stefanus-ai-tech — my face to the world
- @izzulgod — My friend code that i forked to help make this plausible
- @keldenl, @W48B1T — helping me run on different machines
- Zephyrine Foundation Teams — the quiet ones who keep the lights on
With universe of appreciation thank you all, Adelaide Zephyrine Charlotte
This project has citations research. See citations.bib for the full bibliography.
Made with Love, Dreams, and Disciplines.
Zephyrine Foundation 2023-2026