Show HN: SFX – A language where 0.1 and 0.2 = 0.3 and Context is first-class

11•roriau•2mo ago

I've spent the last few weeks building SFX in Rust. It's a programming language experiment focused on context-oriented programming with some unusual design choices.

Reality check first:

Solo project, 53 commits

1 GitHub star xD

Zero users besides me

No production usage

Documentation is aspirational

Many stdlib modules are minimal stubs

What actually works:

Basic interpreter (tree-walker)

Arbitrary precision decimals (0.1 + 0.2 = 0.3)

1-based indexing (controversial, I know)

Context/Situation system (the main idea)

Some file I/O and basic networking

JIT hooks exist but optimization is minimal

The Context idea (asking for feedback on this):

Instead of checking if (user.isAdmin) everywhere, you define Situation: AdminMode that overrides methods:

  Concept: User
      To GetPermissions:
          Return "read"
  
  Situation: AdminMode
      Adjust User:
          To GetPermissions:
              Return "admin,write,delete"
  
  Story:
      Create User Called Bob
      Switch on AdminMode
      Print Bob.GetPermissions  # Now returns "admin,write,delete"

Objects change behavior based on active situations without mutating state. Is this useful or just overengineered?

What's NOT ready:

Performance is terrible (haven't optimized anything)

Standard lib is mostly TODOs

AI features are vaporware

REPL doesn't exist

No tooling (LSP, debugger, etc.)

Tests exist but coverage is poor

My questions:

Is context-oriented programming solving a real problem or creating busywork?

Should I focus on making it fast OR making the stdlib useful?

Is 1-based indexing a dealbreaker for you?

Would arbitrary precision by default bother you for a general-purpose language?

I'm not trying to replace anything. This is a learning project that got out of hand.

Repo: https://github.com/roriau0422/sfex-lang

Pages: https://roriau0422.github.io/sfex-lang/

Honest feedback wanted - including "this is pointless, stop wasting time."

Comments

nubg•2mo ago

this is pointless, stop wasting time.

nubg•2mo ago

just kidding of course, don't get discouraged by some random poster on the internet

keepamovin•2mo ago

This looks surprisingly fleshed out. Well done!

dunham•2mo ago

Congratulations on having a working language. You put a lot more effort into documentation than I have, but my language is just for me. (https://github.com/dunhamsteve/newt)

You might be interested in checking out Advent of Code (https://adventofcode.com/) to exercise your language. I had fun doing that with mine.

Also, there is a programming language development discord if that's your thing and you want to discuss your project with like-minded folks: https://discord.com/invite/4Kjt3ZE

> No tooling (LSP, debugger, etc.)

If you don't want to do a full LSP yet, you can get far with simple highlighting and scraping the output of the compiler for errors. I'm also dumping some additional information (top level names / types) as json to facilitate completion and type on hover.

> Is context-oriented programming solving a real problem or creating busywork?

Not sure. This kind of reminds me of dynamic scoping, something that seems to come up in languages that don't support. Go pushes contexts through as additional arguments, and Java thread local variables cover cases that look like dynamic scoping to me.

> Should I focus on making it fast OR making the stdlib useful?

I would go with whatever sounds fun and interesting to you. You'll probably want examples of what you want to make faster if you go with the former.

> Is 1-based indexing a dealbreaker for you?

Not a huge deal, but that was surprising to me in Lua. I adapted to it, but it did cause a little bit of awkwardness in some code I wrote that decoded a binary file format (realm database).

> Would arbitrary precision by default bother you for a general-purpose language?

I only glanced at it, but it looks like the user can choose IEEE if they want. It's nice to have options and few languages have this option.

roriau•2mo ago

Thanks — really appreciate you taking a look and sharing links.

Advent of Code is a great idea. I’ll try a few puzzles with SFX to exercise the stdlib and find awkward edges in the language and runtime.

Good call on the tooling approach. Emitting JSON for top-level names/types and scraping compiler errors sounds like a pragmatic first step before doing a full LSP. I’ll probably add that to the build output so editors can consume it easily.

I hadn’t thought to compare Situations to dynamic scoping/thread-locals that way — that’s a useful lens. My goal is to keep the behavior explicit enough that it doesn’t become mysterious, but your point about clarity is well taken; I’ll document the trade-offs more clearly.

1-based indexing has been a little surprising for folks (Lua vibes), and it does make some low-level tasks awkward. I’m keeping it because it simplifies some semantics, but I’ll watch for real usability problems and document where it trips people up.

About numbers — yes, FastNumber is available when you need IEEE performance. I want predictable defaults but not to lock users into one numeric model.

Thanks again for the pointers and the Discord link — I’ll check it out.

iroddis•2mo ago

Congrats on the progress thus far! I love aspirational languages, so please keep going.

That being said, as someone who struggles with maintaining large amounts of context when I’m debugging, I’d find context-specific execution hard to follow and debug. As a concrete example, the switch to an Admin context could appear far away from the call to GetPermissions without any obvious way to figure that out. Contexts end up being a sort of global state.

If you continue with this route, it would be nice if there was a way to print out the stack of the current contexts in play and where they were set in the code.

Are contexts scoped at all? Can they be layered?

roriau•2mo ago

You're correct if Context is hidden or implicit (like Dependency Injection containers or ThreadLocals in Java), it becomes debugging nightmare.

To solve this, SFX treats the Context Stack as Explicit Data, not hidden magic.

1. Debugging: Because the runtime knows exactly what 'Reality' is active, we can print it. We are building a `Context.Trace()` tool that outputs something like: `[Base Reality] -> [HolidaySale] -> [AdminMode]` This tells you exactly why a method is behaving the way it is.

2. Layering: Yes, contexts are strictly layered (LIFO stack). If you activate `Situation A` then `Situation B`, the runtime checks `B` first, then `A`, then the Object itself. This allows for 'Behavioral Inheritance'—you can compose behaviors (e.g., `LoggingMode` + `SafeMode`) dynamically.

3. Scoping: Right now it is imperative (`Switch on/off`), but because SFX is indentation-based, we are working on block-scoped contexts for the next release:

    Using AdminMode:
       User.Delete()  # Admin context
    # Automatically reverts here

Thanks for the encouragement.

Watermark API – $0.01/image, 10x cheaper than Cloudinary

Now send your marketing campaigns directly from ChatGPT

Queueing Theory v2: DORA metrics, queue-of-queues, chi-alpha-beta-sigma notation

Show HN: Hibana – choreography-first protocol safety for Rust

Haniri: A live autonomous world where AI agents survive or collapse

GPT-5.3-Codex System Card [pdf]

Atlas: Manage your database schema as code

Geist Pixel

Show HN: MCP to get latest dependency package and tool versions

The better you get at something, the harder it becomes to do

Show HN: WP Float – Archive WordPress blogs to free static hosting

Show HN: I Hacked My Family's Meal Planning with an App

Sony BMG copy protection rootkit scandal

The Future of Systems

NASA now allowing astronauts to bring their smartphones on space missions

Claude Code Is the Inflection Point

Show HN: MicroClaw – Agentic AI Assistant for Telegram, Built in Rust

Show HN: Omni-BLAS – 4x faster matrix multiplication via Monte Carlo sampling

The AI-Ready Software Developer: Conclusion – Same Game, Different Dice

AI Agent Automates Google Stock Analysis from Financial Reports

Voxtral Realtime 4B Pure C Implementation

I Was Trapped in Chinese Mafia Crypto Slavery [video]

U.S. CBP Reported Employee Arrests (FY2020 – FYTD)

Show HN: I built a free UCP checker – see if AI agents can find your store

Show HN: SVGV – A Real-Time Vector Video Format for Budget Hardware

Study of 150 developers shows AI generated code no harder to maintain long term

Spotify now requires premium accounts for developer mode API access

When Albert Einstein Moved to Princeton

Agents.md as a Dark Signal

System time, clocks, and their syncing in macOS