u/Cool-Statistician880

What if kernel/userland/baremetal restrictions were enforced semantically at compile time?

I’ve been building an experimental LLVM-native systems language called FALCON where deployment profiles ("userland", "kernel", "baremetal") are treated as actual compile-time semantic laws instead of optional conventions.

The compiler validates environment/profile compatibility during IR validation, so invalid combinations fail at compile time rather than relying on runtime assumptions or documentation.

Some core ideas:

- compile-time semantic profiles

- capability-based library enforcement

- environment-aware compilation

- LLVM native codegen

- direct C interoperability

- zero-runtime assumptions for low-level targets

The overall goal is basically:

Python-like ergonomics with native systems-level control and profile-enforced safety boundaries.

Still very early and experimental, but I’d genuinely love feedback from people interested in:

- compilers

- systems programming

- LLVM

- kernel/baremetal tooling

- low-level language design

Repo:

https://github.com/jhonpork1233-beep/FALCON

reddit.com

uploaded my Spotify downloader GUI

I recently posted about the small Python GUI I made for saving songs locally from Spotify links, and a few people genuinely asked for a repo/link, so I cleaned it up a bit and uploaded it.I also tried to make the setup as beginner-friendly as possible with screenshots and step-by-step instructions since not everyone here is technical.If anyone faces issues with setup/UI or has suggestions to make it easier, let me know. If this actually ends up helping a lot of people, I’ll keep improving it and maybe turn it into a more polished app over time.And if there’s any other small feature or improvement that would genuinely help, feel free to ask I’ll try my best to add it.

GitHub link:https://github.com/jhonpork1233-beep/spotify-local-downloader

Built a local Python GUI app to download Spotify tracks for my MP3 player (Ad-free & offline)

​I vibecoded a small Python GUI app to download Spotify songs locally, and I'd love to share it if anyone needs it so people can enjoy their music without ads and actually store it permanently if they want. The current workflow is a little annoying since it requires copy-pasting song links into a file before running cause it uses yt-dlp, but it gets the job done. Let me know if you're interested if yes then I could just drop the code here so you guys can just run it and download the ones you want

I’ve been working on a systems language experiment called Falcon, built around one core idea:

The execution environment is enforced at compile time, not decided externally.

Falcon introduces profiles:

- userland → heap, runtime, I/O allowed

- kernel → no heap, no runtime calls, restricted operations

- baremetal → only hardware-level access (MMIO), no runtime at all

These are not runtime modes or build flags in the usual sense they are enforced as part of the compilation pipeline.

If code violates the selected profile, it fails to compile.

Design overview:

- Implemented in Rust

- Pipeline: AST → IR → LLVM backend

- IR is intended to be the single source of truth

- Profile filtering + validation happens before codegen

- No runtime branching based on profile

Current features:

- Compile-time profile enforcement (userland / kernel / baremetal)

- LLVM-based code generation

- Basic type system (currently being hardened — removing fallback behavior)

- Partial ownership checks (use-after-move detection)

- Cross-compilation support (x86, ARM, AVR targets)

Current limitations:

- Not memory safe (no borrow/lifetime system yet)

- Generics are incomplete

- Closures currently non-capturing

- Type checking still being tightened

Repo:

https://github.com/jhonpork1233-beep/FALCON

I’m looking for feedback and review on the design, implementation, and overall direction.

u/Cool-Statistician880 — 26 days ago