Flux

A general purpose, statically typed, broadly mid-level, object-oriented compiled programming language for easy control over data.

What is Flux?

Flux is a systems language that combines the performance of C with the readability of Python. It's for everyone, designed to have all the bells and whistles you could want in one place. Gone now are the days of writing your performance critical code in one language and calling it from another.

Characteristics:

Manual memory management
Compiler that does not fight you
First class data control features
Consistent grammar and syntax constructs throughout
Rich operator set with distinct bitwise set
Everything stack allocated unless otherwise specified
Everything is zero initialized unless otherwise specified
Custom infix operator support
Templates without SFINAE
Opt-in ownership without a borrow checker

Design Philosophy

Flux follows a "high-trust" model:

The language provides powerful tools
The programmer is responsible for using them correctly
Explicit is better than implicit
Performance and control over safety guarantees

This means:

Manual memory management (no garbage collection)
No borrow checker (you manage lifetimes)
Direct hardware access when needed
Full compile-time programming capabilities

Ideal Use Cases

Flux is well-suited for:

Embedded systems - Direct hardware register access
Network protocols - Zero-copy packet parsing
File format handling - Binary data interpretation
Game engines - Memory-efficient entity systems
Device drivers - Memory-mapped I/O
Performance-critical code - When you need C-level control

Flux may not be the best choice for:

Applications where memory safety is critical
Projects requiring a mature ecosystem
Teams new to systems programming
Rapid prototyping of business logic

Current Status

Flux is in active development. The language specification is complete, but implementation is ongoing.
The standard library is the current focus.

What exists:

Complete language specification
Keyword Reference
A Flux style guide
Tutorials for beginner and adept programmers
Clear syntax and semantics

What's being built:

Compiler Implementation ✅
Standard library (In-progress)
Build tooling
IDE (In-progress)
Package manager (In-progress)
LSP (In-progress)

Getting Involved

Discord: Join the Flux community
Contribute: The project welcomes contributors
Feedback: Share your thoughts on language design

Learning Resources

Language Specification - Complete language reference
Getting Started Guide - Tutorial for new users
Examples - Real-world Flux programs
Windows Setup Guide
Linux Setup Guide

Star History

Example: Complete Program

#import "standard.fx";

struct Packet
{
    unsigned data{8} type;
    unsigned data{16} length;
    unsigned data{32} timestamp;
};

def main() -> int
{
    byte[7] bytes = [0x01, 0x00, 0x20, 0x5F, 0x12, 0x34, 0x56];
    Packet pkt = Packet from bytes;
    
    print("Type: \0");
    print(pkt.type); print();
    print("Length: \0");
    print(pkt.length); print();
    print("Time: \0");
    print(pkt.timestamp); print();
    
    return 0;
};

Note: Flux is a systems programming language that assumes you understand memory management and low-level programming concepts. If you're new to systems programming, work through the tutorial documentation carefully.

🤝 Contributing

Flux is actively developed and approaching self-hosting. We're building the future of systems programming.

Current Status: 100% of reduced specification complete, working compiler, real programs running.
Bug fixing and refactoring are currently the names of the games. There are still some small issues here and there, as well as minor missing functionality. More features may end up being added before the bootstrap.

FluxLang

Install / Use

README