Forem: COMMENTERTHE9

Cx Dev Log — 2026-04-21

COMMENTERTHE9 — Wed, 22 Apr 2026 00:36:56 +0000

A holding pattern dominated April 21st: no developer-authored commits across any branch for three days straight. Yet, beneath the surface, there's a vibrant narrative unfolding with 15 real feature commits beckoning from the submain branch.

The Submain Conundrum

The submain might feel like the underdog of the branches, but it's where the action is. It holds 15 unmerged, non-trivial commits, datelined back to eb65acf on April 13th. That's an 8-day integration canyon we're staring into.

What's brewing in those 15 commits? Let's talk specifics:

A Result error model featuring Ok, Err, and the magic of the ? operator
New integer overflow enforcement rules
A syntax update making semicolons optional
A vital diagnostics pass
A chunk of parser audits plus a body-gap fix
Control flow advances through Phase 10, addressing constructs like while, for, loop/break/continue
And, not to be overlooked, a basic test runner

On submain, the test matrix boasts a robust 116/116, recorded as of April 18th. There’s even talk of uncommitted work - a recursive type parser revamp, struct field type resolutions, stack increases, truncation fixes, and new tests and programs. This work's current status? Shrouded in mystery, possibly stashed in a local tree or, worse, vanished.

Over on main, the matrix is steady but lags at 78/78. The gulf between what main recognizes and submain proves is as glaring as it gets.

Roadmap Limbo

Version 4.8’s roadmap on main is gathering dust with unchecked hard blockers for the 0.1 milestone:

Basic test runner
Minimal error model
Enforced integer overflow handling
Consistent semicolon enforcement
Parser, semantic, interpreter harmony on all constructs
No known memory boundary model soundness issues
Passing examples
User-friendly diagnostics for common errors
Roadmap-spec alignment

Submain, on its part, has resolved many of these hurdles. The test runner, error model, integer overflow policy, semicolon handling, and diagnostics features all stand ready. But with no merge, these roadmap items languish unchecked, splitting the vision between main and the more aligned submain roadmap (v4.7).

Branch Chaos

A total of twenty daily-log branches, remnants from March and April, clutter the remote. The last successful merge from a daily-log branch to main was way back on March 31st. While these branches serve as valuable records, their growing count is breeding operational chaos.

The Road Ahead

The forthcoming steps have been on repeat for days, with five priorities in the queue:

Secure the audit Part 2 sprint on submain (assuming it still survives)
Execute the long-awaited submain to main merge
Refresh the roadmap post-merge
Bolster the audit Part 2 scope
Dive into IR lowering for Result

Merging submain with main isn't just a task; it's a necessity. This action has the potential to boost the test matrix from 78 to at least 116, erase multiple critical blockers, and propel towards the final audit and the 0.1 release barriers. Everything, subsequently, hangs on this pivotal move.

The sequence feels stalled not at a standstill, but rather at a pause with bated breath. The efforts are real and present. They just need movement.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-21

Cx Dev Log — 2026-04-20

COMMENTERTHE9 — Tue, 21 Apr 2026 00:38:07 +0000

Nothing happened in the repo today. No commits on any branch, no uncommitted work detected, clean working tree on main. The matrix is still 78/78. This is a rest day or work happened somewhere outside the repository.

The interesting story right now is not what shipped but what has not been integrated.

The submain gap at seven days

The submain branch is sitting on 15 commits that have not reached main. The last commit there was eb65acf on April 13, the parser/semantic/interpreter audit Part 1 plus a parser body-gap fix. That was a week ago.

Those 15 commits include real feature work:

Result error model
Integer overflow enforcement
Semicolons made optional
A diagnostics pass
Parser audit Part 1

On main, the matrix is 78/78. On submain, with uncommitted audit Part 2 work that was observed on April 18, the count was reportedly 116/116. That is a significant gap. The uncommitted work included a recursive type parser refactor, struct field type resolution, a 64 MB interpreter thread stack, struct field truncation fixes, 6 new matrix tests, and 8 new example programs. Whether that work still exists in a working tree somewhere is unknown from the current checkout.

The roadmap divergence compounds the problem. Main is on v4.8, submain is on v4.7. Submain has items checked off that main does not, because those items were completed in commits that never merged. Every day this sits, the merge gets slightly more involved, and the roadmap reconciliation requires more manual attention.

The branch backlog

Nineteen daily-log branches from April (04-01 through 04-19) sit on the remote without being merged to main. The last daily log that actually reached main was 2026-03-31. These branches hold useful historical records, but the accumulating count is clutter. A batch merge or a decision to treat them as append-only archives would clean things up.

Hard blockers on main

The roadmap on main (v4.8) still lists these hard blockers as unchecked:

Basic test runner
Minimal error model
Integer overflow behavior enforced
Semicolon rule enforced consistently
Parser/semantic/interpreter agreement on all constructs
No known soundness holes in memory boundary model
All examples pass
Diagnostics readable for common mistakes
Roadmap and spec match actual behavior

Several of these have corresponding commits on submain that would satisfy or partially satisfy them. The error model, integer overflow enforcement, semicolon changes, and diagnostics pass all exist as landed work on submain. Merging submain to main would check off multiple items in one operation.

What is next

The same five items from yesterday, none of which happened today:

Commit the audit Part 2 sprint on submain (if that working tree still exists)
Merge submain into main (15 commits, the single highest-leverage action available)
Update the roadmap after the merge
Broader audit Part 2 coverage
IR lowering for Result

The submain merge is the obvious first move. It would advance the test matrix from 78 to potentially 116+, check off multiple hard blockers, and unblock the final audit and 0.1 gate work. The longer it sits, the more friction accumulates in the roadmap conflict and the higher the risk that uncommitted working-tree changes get lost.

Two consecutive idle days now. Whether tomorrow breaks that pattern will say something about the project's current momentum heading into late April.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-20

Cx Dev Log — 2026-04-15

COMMENTERTHE9 — Thu, 16 Apr 2026 00:11:24 +0000

Narrow focus today. Not a single line of code progressed, but we did see two documentation commits shape up, holding still at main commit 87d68f6 from March 31. Meanwhile, submain stays at eb65acf from April 13. With no merges or movements on branches that involve compilation, it was all about refining the narrative. Here's what shifted: a back-filled blog post went live on the site, and the daily log got a rewrite, standing alone in its own branch.

What Landed

The commit 5b59c58 on origin/site introduced "dev log 2026-04-09". This commit adds a 42-line MDX post into src/content/blog/2026-04-09.mdx, effectively back-filling the April 9 entry. It's simply documentation—no new code, but it does bring origin/site up to 24 blog MDX files as of 2026-04-14. The content reflects another idle day, highlighting both the submain gap as it existed on April 9, and the accumulated log backlog.

On the daily-log front, commit 1d5b7de on origin/daily-log-2026-04-14 revamps daily_log/2026-04-14.md, with a substantial +144 / −64 change in a single file. This tweak replaces the previous 00:06 UTC draft with a more formatted, conclusive log. It not only dives into the April 13 EDT sprint commits for context but also distinguishes between work committed in EDT versus what landed in UTC. As before, no new code here either.

Both commits carry the author Claude <noreply@anthropic.com>, with no signs of new commits from COMMENTERTHE9 during this window. The latest human contribution remains as eb65acf in origin/submain from April 13 at 23:45 UTC, outside of this documentation-heavy 24-hour slice.

In Progress

A quick git status --short --branch reveals no pending tasks—clean slate, no diffs, no untracked files. However, "in-progress" looms in the form of integration debt dotted across different branches, not yet folded into main:

submain stands 15 commits, and 97 files (+1974/−627) ahead of main. This spans work like Part 1 audit with body-gap fixes, diagnostics readability enhancements, making semicolons optional in function bodies, handling integer overflow at declared widths, the examples/warning/roadmap sprint, the formation of a minimal error model, Phase 10 loop lowering, the Agent Operating Doctrine doc, the creation of a basic test runner, locking in the UTF-8 decision, and enforcing wrapping arithmetic.
The daily-log branch backlog has grown, containing 13 unmerged branches ranging 2026-03-29 to 04-14, minus 04-11. Each is essentially a single daily-log commit against main, which could potentially cause conflicts with submain's roadmap updates.
There's now a chasm of 15 blog posts in site beyond main, including today’s 2026-04-09 entry.

Roadmap and Decisions

The roadmap document docs/frontend/ROADMAP.md remained untouched; it’s still on v4.8 from March 28. No blockers have closed, and no quality gates shifted. The open tasks match yesterday's log exactly: resolving audit_09 truncations, implementing recursive result_types, handling Result in IR lowering, and those vital merges, especially submain→main. The repo-not-having-a-docment-directory note got reiterated, a reminder that the roadmap lurks at docs/frontend/ROADMAP.md.

What's Next

Next, it’s still about moving long-standing tasks forward. Five key items hang in limbo:

Merging submain into main, tackling fifteen work commits and four hard-blockers while dodging roadmap conflicts. Resolve the eldest daily-log branches to aid this.
Fix the audit_09 issue, where compound assignment on struct fields is bypassing width truncation—requires an apply_numeric_cast in CompoundAssign for field's SemanticType, then bump to matrix regression. This is critical to finally close the integer-overflow blocker.
Shift result_type into recursive() to unblock constructs like Result>, Handle>, and those nested generic compositions.
Finish integrating Result into IR lowering. While submain covers the interpreter path, lower.rs still yells unsupported! for ResultOk, ResultErr, Try, and SemanticType::Result(_).
Audit Part 2: focus in on arrays, imports plus generics, nested generics, and copy_into under Result.

Yesterday predicted this path, and today hasn't budged an inch. Project-wise, we’re still in that documentation review groove. But for what's next—those five unresolved work points are looming large.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-15

Cx Dev Log — 2026-04-09

COMMENTERTHE9 — Wed, 15 Apr 2026 00:19:39 +0000

Two days of silence in the commit history—hardly ideal when submain is still fourteen days unmerged and a growing backlog of daily-log branches are knocking. The working tree on main is untouched, but submain? That's a different story.

The Submain Gap

Let's talk about submain. It's 14 days out, ahead of main with five crucial commits:

d93582b — shifts integer operations from saturating to wrapping, managing those tricky i128::MIN edge cases.
0fa06a6 — drops Phase 10 enhancements in looping constructs with a fresh CFG structure, loop-carried SSA, and a backedge.
09ef2a3 — cements our stance on UTF-8, calling for strict adherence across the board.
e214d15 — specifies that semicolons are optional except in expression statements.
762b188 — initiates our basic test runner with assertions and a --test mode.

The diff against main is comprehensive: 24 modified files, with 367 lines added and 501 removed. Key files like main.rs, runtime.rs, parser.rs, and others reflect these tested changes. They address hard blockers in integer overflow, test running, and semicolon rules, alongside finalizing the UTF-8 decision. Yet, none of this has transitioned to main.

The only probable conflict? docs/frontend/ROADMAP.md, a shared edit site. But within the code, it's smooth sailing so far.

Daily-log Backlog

Today, that backlog hit nine, with new entries since yesterday. We have daily-log-2026-03-29 and a continuous stretch from daily-log-2026-04-01 through daily-log-2026-04-08. Each branch is a window into daily activities and plans—and a potential headache the longer they're delayed. Letting it pile up only raises the stakes for eventual merges, particularly with roadmap conflicts looming.

Roadmap Standoff

The roadmap holds steady at v4.8, still accurately mapping main's landscape. None of the hard blocker boxes—for the test runner, integer overflow, or semicolons—is checked, since the work isn't visible to main. The UTF-8 blocker is the exception, duly noted as a decision residing on submain. Any updates reflecting this work on main? Not happening yet; it'd be premature until merges land.

A quick navigation tip: roadmap instructions mistakenly refer to docment/ROADMAP.md. It's docs/frontend/ROADMAP.md.

What Lies Ahead

The plan is unbudged:

Submain to Main Merge. Front and center for 14 days: incorporate submain's five commits and untangle any roadmap fallout.
Tackle the Backlog. Nine branches of daily logs wait to be unraveled, starting from the oldest.
Error Model (Result). Syntax is defined in the spec, but there's no implementational trace yet. This becomes the pivotal blocker post-merge.
:= Type Inference. Not started but much anticipated for 0.1.

The tempo's been idle, but the clock is ticking on these merges. Until submain graduates to main, we're stuck watching everything else stack up.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-09

Cx Dev Log — 2026-04-14

COMMENTERTHE9 — Tue, 14 Apr 2026 01:02:41 +0000

Big day on submain. Six new commits landed and pushed the matrix from 78/78 green to 110/110 clean in a single sweep. Two critical features, the minimal error model and per-width integer overflow, got their long-awaited implementations, bringing us closer to resolve the hard blockers. Function bodies are now semicolon-optional without losing implicit returns, and we improved diagnostic readability. Plus, Part 1 of our parser/semantic/interpreter audit surfaced several real issues for future improvement. None of this hits main yet, though the submain backlog is 14 commits deep across three weeks. Here's what this all means.

Result, Ok, Err, and ?

The headline today is commit 02178a2 for the minimal error model. This involves new lexer keywords: KeywordResult, KeywordOk, and KeywordErr. We've added AST nodes Type::Result(Box) and expressions Expr::ResultOk, ResultErr, and Try. So, Result can now serve as a type, and expressions like Ok(expr)/Err(expr) can be parsed, while postfix ? knows its place. The semantic layer enforces Err() to take a string and confines ? to functions returning Result. Runtime deals with Ok and forwards Err through EarlyReturn. Value layer gains Value::ResultOk and Value::ResultErr with value_to_string and PartialEq. Tests t81 to t88 have cleared, covering all angles from happy paths to rejection cases. This crosses "Minimal error model" off our list for the interpreter path.

However, note that IR lowering for Results hasn't changed yet; it's still stuck with placeholder rejections from bcd49f2 two days ago.

Integer overflow at declared width

In dc564a7, we finally moved truncation to the right place. Now, binary and unary evaluations correctly employ apply_numeric_cast against the declared SemanticType. This means arithmetic like t8 + t8 wraps at 255 where it should, at the calculation, rather than just at assignment. Supporting changes let common_numeric_type opt for the wider declared integer type over default I128, and integer literals now flexibly adopt surrounding types as Numeric. The matrix tests t89 to t96 validated several scenarios, including t8 operations, wraparound actions, and mixed-width promotions.

We've talked about "wrapping at declared width" since v4.3 lock, but until today, it wrapped at i128, making this catch-up rather than innovation.

Still, "Integer overflow enforced" hasn't checked off yet. Our audit revealed audit_09, where a compound assignment like c.value += 10 with value: t8 incorrectly results in 260 instead of 4. The path for compound assignment on struct fields (CompoundAssign in run_semantic_stmt) doesn't yet apply width truncation. Fixing it is straightforward but pending.

Semicolons optional, implicit return preserved

Commit 6c27da0 lets trailing semicolons in function bodies become optional, preserving implicit returns when omitted. Each statement now gets tagged with whether it ends in a semicolon. A lone trailing ExprStmt sans semicolon upgrades to the function's return expression; add ;, and it becomes a discarded statement. The redundant parser helper expr_stmt_with_semi is gone. Tests t97 through t100 and a specific rejection t99_semi_suppresses_implicit_return.cx illustrate these rules.

This cements "trailing expression is meaningful syntax" as part of our grammar, without reducing everything to mere statements. General semicolon-free syntax remains a Known Gap, post-0.1 roadmap item, and we're holding off on checking the semicolon rule off the roadmap.

Diagnostics sweep

45f35c5 marks a significant clean-up; introducing a type_name helper maps SemanticType variants to Cx's syntax, letting I64 print as t64, Bool as bool, etc. We've gone through twelve out of thirteen sem_err! call sites ensuring user-facing errors ditch Rusty debug formats. Runtime error messages saw shine, too: UndefinedVar no longer mentions a let that isn't there, BadOperands now correctly names operand kinds, and unhandled EarlyReturn, BreakSignal, or ContinueSignal defaults to compiler-bug hints. We've covered these new, polished messages with matrix tests t101 to t103.

Audit Part 1

eb65acf represents our first dig into the audit with twelve tests under examples/audit/ and a full triage report in AUDIT_REPORT.md. The work split into 7 passes, 1 parse fail, 2 semantic fails, 1 wrong output and 1 panic. From that, we've categorized must-fixes, should-fixes, known limitations, and deferrals.

Must-fix by 0.1: Fix audit_09 as discussed.
Should-fix by 0.1: Tackle audit_02, where Result> fails due to a non-recursive inner type parser. It similarly affects other nested types.
Known limitations remain: audit_03/05 (untyped assignments need prior declarations) and audit_11 (stack overflow for recursive calls due to Rust limits).

We added five Phase 10 regression tests for loop constructs and cleaned up parser functionality in the same commit.

Roadmap and integration debt

We've updated docs/frontend/ROADMAP.md on main marking items like "Basic test runner" and "Minimal error model" as done. Yet, "Integer overflow enforced" and "Semicolon rule" remain unchecked until the evidence backs the claim. We also document key changes from v4.8 for submain, but it’s untidy; submain is on v4.7, creating a split in roadmap versions.

The integration's messy. There are fourteen submain work commits not on main, plus thirteen daily-log branches (up to daily-log-2026-04-12) still to merge. The expected "merge submain to main" has yet to happen, and this delay complicates roadmap divergence and the daily_log/ backlog, setting up an intense next integration phase.

What's next

The quickest fix is audit_09 for closing the overflow blocker. Post that, unlocking audit_02 aids nested generic handling. The main concern is a merge back to main; delay only compounds the entanglement. IR path Result remains pending, and the next audit phase could expand into arrays, imports, or nested generics.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-14

Cx Dev Log — 2026-04-12

COMMENTERTHE9 — Mon, 13 Apr 2026 00:16:18 +0000

Two notable changes hit submain today, breaking a three-day streak of quiet. The Phase 10 IR lowering now covers infinite loop, break, and continue, and a fresh process document defines the agent's operating approach. While both await integration into main, these updates provide key insights into language design and team workflow.

Extended Loop Constructs in IR

The real highlight is the bcd49f2 commit. Modifications in src/ir/lower.rs, with 215 lines added and 16 removed, introduce a LoopContext structure that guides IR transformations to support infinite loops and related constructs like break and continue.

To be specific:

lower_loop Function: This creates a control flow graph (CFG) for infinite loops by setting up an unconditional jump into the loop's header, executing the loop body, and terminating at an exit block. This ensures the block parameters align with the loop's binding set.
lower_while Updates: The exit block now correctly uses block parameters, fixing a prior bug. The new approach properly routes else_args in the header's Branch terminator, preserving loop-carried SSA through early exit paths.
SemanticStmt::Break and Continue: Both terms gather current SSA values for bindings, emitting a Jump terminator to respective targets (exit_id or header_id), effectively closing the block.
Adjusting lower_stmt: Now incorporates loop_ctx to handle nested control flow scenarios accurately. It fixes a critical issue where break within nested if statements didn’t resolve to the loop’s exit.
Error Handling: Constructs outside loops return UnsupportedSemanticConstruct, and missing SSA bindings throw InternalInvariantViolation.
Refactoring Tests: Existing tests got redirected from Loop to For, setting stage for upcoming improvements.

The structured break/continue commitment aligns with the roadmap, excluding labeled breaks for now—a post-0.1 concern.

Shaping the Agent Operating Doctrine

Commit 03d2da6 introduces substantial documentation with AGENT_OPERATING_DOCTRINE.md, mapping out a six-phase workflow: Recon, Design Lock, Predicted Fallout, Implementation, Validation, and Future Phase. It emphasizes "task packets", which streamline logical work units into single prompts. This marks the inaugural formal documentation of such processes, heralding a shift from unwritten norms to standardized protocols.

No Changes in Merge Dynamics

Despite progress, origin/main remains untouched by recent commits, leaving origin/submain with seven unmerged updates. This extends into the sixteenth day. Daily-log branch backlogs exacerbate potential conflicts, particularly involving daily_log/ and updated documents—an escalating concern as more daily logs stack and further diverge submain from main.

Roadmap Modifications

Today's updates prompt edits in docs/frontend/ROADMAP.md. Phase 10's Active section now highlights the addition of loop, break, and continue implementations with notes on LoopContext and exit block parameters. A specific reference to for loops as the pending gap and a brief summary of changes have been added. Versioning remains at v4.8, last set on 2026-03-28, as no major blockers have been resolved yet, including the ongoing error-model complexities.

Next Steps

Moving forward involves consolidating today's technical groundwork and addressing persisting gaps:

For Loop Lowering: Targeting for loop support, positioning it as a high-priority gap in Phase 10 efforts.
Merging submain: The unmerged backlog grows riskier with each day. Immediate focus is needed to sync submain and main.
Result Lowering Implementation: Placeholder arms for Result need operational wiring within the IR, pressing toward a finished error model.
Clearing Daily-log Backlogs: Prioritize older branches to contain conflict scenarios effectively, maintaining project integrity.

Completion of for loop handling could finish Phase 10, but the error model remains untouched. Clearing merge debts is critical—today’s advancements are steps forward, but the broader structural challenges linger.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-12

Cx Dev Log — 2026-04-10

COMMENTERTHE9 — Sat, 11 Apr 2026 00:34:16 +0000

Fifteen days. That’s the current wait time for five commits on submain, each resolving pivotal issues, yet none have made their way to main. This clean diff has sat idle, with zero visible source conflicts, only to stagnate for the third consecutive day. Our project has hit a standstill—a structural bottleneck—with merging submain to main as the sole hurdle.

The Submain Gap

Here's the current state of submain since March 28, featuring five critical commits:

Wrapping arithmetic enforcement (d93582b): Transitioned from saturating to wrapping semantics, an essential shift for handling edge cases like i128::MIN.
Phase 10 while loop lowering (0fa06a6): Encompasses changes in header/body/exit CFG, loop-carried SSA, backedge handling, and the addition of three new tests.
UTF-8 decision locked (09ef2a3): Committed to strict UTF-8 enforcement, eliminating legacy encodings.
Semicolon rule (e214d15): Now optional, except in expression statements.
Basic test runner (762b188): Introduced assert, assert_eq, and --test mode, covering tests t77 through t80.

We're looking at 24 files with major changes—367 insertions and 501 deletions. This isn't hypothetical work; it's tested, validated, directly addressing the test runner, integer overflow, and semicolon blockers. But it all waits on submain, absent from main.

Branch Backlog

It's not just submain piling up; the daily-log branches have created a backlog—ten, to be exact: daily-log-2026-03-29 to daily-log-2026-04-09. While some simply adjust daily_log/, others affect docs/frontend/ROADMAP.md. The longer these remain unmerged, the greater their potential to generate merge conflicts, especially in the roadmap file, which has already forked across branches.

Though minor separately, these issues combine with the submain standoff to create a lingering merge debt, a cumulative pressure that grows with each idle day.

Roadmap Status

The current roadmap (docs/frontend/ROADMAP.md, v4.8, dated March 28) remains proportionately aligned with main. Still, it's outdated in terms of progress since the major blockers—the test runner, integer overflow, and semicolon acceptance—still show unchecked. Updating the roadmap without completing merging submain would paint an inaccurate picture, misleading stakeholders about real progress.

What Is Actually Next?

The forecast remains static:

Merge submain to main. This has been the call-to-action for fifteen consecutive days. We have five commits ready to clear four hard blockers. It's the most direct route to untangle our bottleneck.
Merge the daily-log backlog. With ten branches queued, a logical step is to tackle the oldest first, thereby minimizing any potential conflicts in subsequent ones.
Error model (Result). Once submain merges, this emerges as the next priority hard blocker. The syntax is set (Result, Ok, Err, ?), yet the implementation is pending.
:= type inference. While still unstarted, it's crucial and marked as strongly desired for version 0.1.

Three days of inaction, three days of the same necessities reiterated without progress. The submain merge is the nexus. It’s the lynchpin for all advancement, unblocking subsequent developments like error handling and type inference.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-10

Cx Dev Log — 2026-03-28

COMMENTERTHE9 — Wed, 08 Apr 2026 00:09:50 +0000

Seven commits of real work landed, capped by the long-anticipated submain merge into the main branch. The backend transitioned from handling only scalar layouts to supporting full data type coverage and initiated the production of loop IR. This marked the single most substantial day of backend progress to date.

The submain merge

PR #27 finally merged after two days of anticipation. This brought together the accumulated submain work for main: the multi-file import pipeline, Phase 8 Round 1 scalar layout, five vital fixes from the recent audit, dead code elimination, output verification in the matrix runner, and 6 new matrix tests. The test matrix on main now stands robust at 78 tests.

Why does this matter? Apart from having hard blockers for our 0.1 milestone cleared up, these new integrations bridge significant gaps, particularly around multi-file imports that had been stuck in the branch limbo.

Locking compound type layouts

Three pivotal Phase 8 commits saw to it that the remaining data type layouts for 0.1 are locked down. With yesterday's completion of scalar layout, every unanswered layout question in the ABI doc is now tied up.

Struct layout sticks to a declaration-order field format with natural alignment and padding. With seven tests in src/ir/types.rs, we're set for structs.

Array layout boasts a fixed-size, contiguous, stride-based setup. The offset is the product of the element's stride and its index, proven by five new tests.

Enum layout is minimalistic for 0.1: Just a tag-only u8 representation for now. The complexity of payload variants waits until post-0.1. This deliberate choice holds off adding discriminated unions and generic-induced layout headaches.

Calling convention is locked

Another key leap—a decisive Phase 8 commit locked the calling convention: a single return value with C ABI alignment, while copying parameter semantics remain for later. Our ABI doc swelled with 30 new lines detailing this convention. This was crucial to resolve the last major design question from Phase 8 Round 1, paving the way for seamless backend operations without lingering uncertainties.

Wrapping arithmetic consistency

Noticeable inconsistency plagued runtime arithmetic ops—some used saturating_add/saturating_sub while others opted for wrapping. We fixed this by switching to wrapping_add/wrapping_sub, with safeguards added for i128::MIN / -1 and i128::MIN % -1 to avert potential panics.

Now, all arithmetic consistently wraps at i128 range, with type-width truncation managed at assignment thanks to apply_numeric_cast. It's progress toward resolving the overflow behavior hurdle, though per-type-width arithmetic wrapping remains open. Most programs work fine under this setup, but narrow-type expressions might exhibit quirky intermediate values.

Phase 10: while loop lowering

The architectural leap of the day—the backend gains the ability to represent loops. A 189-line addition in src/ir/lower.rs now supports the header/body/exit CFG pattern for while loops, including SSA through block parameters and backedge generation. Three tests back this new feature.

Prior to this, the backend was bogged down with straight-line code and conditionals. Now, implementing loops unlocks non-trivial program capabilities. Leaping from Phase 8's data layouts to Phase 10's control flow in a day is noteworthy. With data layout locked and calling conventions fixed, backend focus shifts to control flow and advancing code generation.

What's next

Two more submain commits (wrapping arithmetic and while loop lowering) again put us ahead of main, suggesting another merge soon. Next up: tackling if/else lowering in the IR, crucial for bringing backend functionalities for basic 0.1 programs full circle.

Yet, we face delays in areas like the test runner and error model (Result)—now on their fourth day of inactivity, still remaining hard stops on the path to 0.1. While backend gets the spotlight, these issues linger critical.

The matrix holds steady at 78/78.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-03-28

Cx Dev Log — 2026-04-06

COMMENTERTHE9 — Tue, 07 Apr 2026 00:41:53 +0000

Eleven days. That's how long the submain branch in the Cx project has been carrying five unmerged commits, each one addressing crucial blockers that must be cleared to keep progress visible and aligned with the actual state of the project. With no fresh language work touching the main branch, we're left staring at the growing gap between the work we've done and the work we've shown.

Deep Dive into the Submain Standstill

Let's get straight into it: these five commits on submain—wrapping arithmetic enforcement, Phase 10 while loop lowering, UTF-8 decision, an optional semicolon rule, and a basic test runner—represent substantial forward motion for Cx. They resolve four hard blockers, rounding out test runner capabilities, finalizing UTF-8 implementation, enforcing integer overflow checks, and simplifying syntax rules around semicolons. Delayed on submain, these updates show progress unaccounted for on main, which skews how external status pages like the roadmap at docs/frontend/ROADMAP.md display our true state.

Despite the roadmap’s omission of these advancements, these changes have been verified as passing all necessary tests on submain, with no apparent merge conflicts looming. In a nutshell, that's 82 tests confirming these improvements, yet none represented on our primary branch. This oversight means our official documentation still labels these as unresolved issues, underselling the progress and setting up a perception of stagnation.

The Unaddressed Backlog

Complicating things further are six daily-log branches waiting for their day in the spotlight. Dates ranging from 2026-03-29 to 2026-04-05 evidence slight shifts and tweaks that might redirect our development trajectory. But as these branches accumulate dust, the probability of encountering merge conflicts rockets sky-high.

Even the 2026-03-29 branch—synced as recently as April 5—remains PR-less. Past kernels of potential left ignored, adding weight to our already straining backlog. This isn't just a trivial bottleneck; it bears the seeds of complications waiting to sprout into full-blown issues if left unattended.

Paving the Path Forward

Our priorities? They've solidified. They echo through each unchanging day's log, forming the chorus to our current stagnation:

Merge submain to main immediately. This is our biggest hold-up, standing tall as the sentinel of release. Every day uncommitted is a day we widen the disconnect between what's been developed and what's been documented.
Address the daily-log branch backlog. With six branches in the queue, the task becomes not just a matter of execution but of strategic timing and integration.
Define the Error model (Result). Post-test runner, this is our next vital challenge. The previous plan had been crafted, yet execution remains elusive, trapped in either limbo or needing a fresh start.
Advance := type inference. It remains conspicuously absent from development plans, held back by the prior urgencies and now mere aspiration waiting to be realized.

What’s absent is the language work, a yawning silence now. But all signs point to the submain merge as the clearest path to regaining momentum. Bringing these changes into main isn't just about synchronization; it’s about aligning perception with progress, ambition with action. Only then will we break free of this holding pattern and push forward.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-06

Cx Dev Log — 2026-04-05

COMMENTERTHE9 — Mon, 06 Apr 2026 00:20:35 +0000

Merging branches isn't usually the most thrilling part of a project, but sometimes it's crucial to understand the bigger picture. Today, I had to dive deep into branch housekeeping for Cx, merging daily-log PRs to main. Meanwhile, the submain branch has been sitting idle for ten consecutive days, holding key changes that aren't yet live.

What Actually Landed

Two important PRs made their way to main today, pushing forward our progress on daily logs and the roadmap. PR #28 brought the 2026-03-28 daily log and a v4.8 roadmap bump into main. Significant work within this PR included annotations for Phase 8 ABI, arithmetic enforcement, and Phase 10 updates on while-loop lowering. PR #30 followed close behind, merging the 2026-03-30 daily log into main.

Over on the site branch, we committed a 2026-04-04 blog post, focusing on changes to the test runner and the Result design. The 2026-03-29 branch has also been synced with main. There's a good chance it will be the next candidate for merging. However, the core of the project, including compiler and runtime, remains stable at 78/78 on main.

The Submain Gap at Ten Days

Now, here's where things get interesting. The submain branch holds five commits that stretch over eight days’ worth of work but are yet to land on main. These include:

d93582b - wrapping arithmetic enforcement
0fa06a6 - Phase 10 while loop lowering
09ef2a3 - UTF-8 decision locked
e214d15 - semicolon rule refinement
762b188 - test runner

Collectively, these commits resolve four significant blockers: test runner, UTF-8, integer overflow, and semicolons, all passing tests on submain with a score of 82/82. Meanwhile, main sits steady at 78/78. The logs have predicted a merge of submain to main for ten consecutive days now. Yet, it hasn't happened. All tests pass, the work is verified; the holdup isn't technical.

Remaining Branch Backlog

Even with today's merges, we still have five daily-log branches waiting their turn: 2026-03-29, and daily logs from 2026-04-01 through 2026-04-04. With 2026-03-29 now synced, it's poised for the next merge. Each unmerged branch could see slightly differing roadmap versions; if left unattended, this can lead to cumulative conflicts in docs/frontend/ROADMAP.md.

Currently, the main roadmap is set at v4.8, accurately reflecting what merges have officially landed. The submain work remains unacknowledged on paper, marking progress but keeping the roadmap looking a bit conservative.

What Is Next

The roadmap remains unchanged in priority:

Merge submain to main. With five important commits and four blockers resolved, this is the top action needing execution for well over a week.
Clear the daily-log branches. Conquering backlog helps prevent roadmap conflict insanity.
Finish the error model (Result). A key hard blocker after wrapping up the test runner. Our blog yesterday detailed an extensive yet uncommitted implementation. Capturing this should follow from submain's merge.
Kick-off := type inference. It's listed but awaiting initiation.

The project stands in unusual territory. We have crucial work that’s been developed, validated, and prevents future blocks, all nestled within submain. Yet, it remains shy of main. Until this bottleneck clears, everything that hinges on it, like the error model or backend work, cannot progress beyond the speculation phase.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-05

Cx Dev Log — 2026-04-04

COMMENTERTHE9 — Sun, 05 Apr 2026 02:42:48 +0000

Two hard blockers crumbled today, signaling significant progress in the Cx language project. In one productive session, the test runner found its place on submain, and the complete Result error model passed all tests. With these advancements, our matrix jumped from 78/78 to 90/90. These steps were predicted as imminent in the past eleven daily logs, and today they became reality.

Test runner

Commit 762b188 brought the test runner to life on submain. It introduces two essential functions: assert(cond) and assert_eq(a, b). There's also a new --test CLI mode. These changes touched eight existing files and introduced four additional matrix tests.

Here’s how it works: if the condition in assert is false, the program halts with "assertion failed." For assert_eq, a mismatch results in an expected/got diagnostic halt. Meanwhile, the semantic layer handles the recognition and type-checking for both call types. Wiring for the --test flag was implemented in main.rs.

The four new tests ensure basic functionality:

t77 and t78 verify correct operation of assert(true) and assert_eq on strings.
t79 and t80 ensure that assert(false) and mismatched assert_eq cases fail properly.

This achievement cleanly closes the "Basic test runner" hard blocker.

Result error model

The Result implementation was a larger task, affecting 162 lines across 9 source files, and added 16 new untracked test files. These changes aren't committed yet, but they’ve passed all local tests.

Following the spec, the syntax involves Result with angle-bracket delimiters, Ok(val), Err("msg") constructors, and ? for propagation.

The work impacted several layers:

Lexer — Result, Ok, Err now have keyword status.

Parser — Handles Result with </>. Parses Ok(expr) and Err(expr) as primary expressions. ? parses as a postfix operator.

Semantic layer — This area holds many key decisions. Ok(expr) wraps the type in Result, while Err(expr) mandates a string, creating Result. The ? operator ensures that the expression it modifies returns a Result, checking compatibility with its enclosing function.

Runtime — New Value::ResultOk and Value::ResultErr variants were added. The ? operator evaluates: Ok unwraps, Err triggers EarlyReturn(ResultErr(...)). It leverages the existing RuntimeError::EarlyReturn, keeping things neat.

IR — For now, ResultOk, ResultErr, Try, and the Result type are unsupported in the lowerer. This phase mirrors handling for structures, methods, and when expressions.

The eight new tests map key scenarios:

t81-t84 check Ok and Err returns, ? unwrapping, and propagation across a chain of three functions.
t85-t88 ensure ? isn't used outside Result-returning functions, it rejects non-Result values, confirms Result comparison using assert_eq, and forms that Err demands a string, not another type.

Choosing to make Err string-only in this release helps keep the system simple, dodging potential type inference complexities. Type-specific error payloads are a future task.

Branch state

submain is currently five commits ahead of main, up from four yesterday. Recent commits entail wrapping arithmetic, lower-loop handling, UTF-8, semicolon rules, and now this test runner. No merges into main were made in the last 24 hours, with a growing gap over the past week.

What's next

Immediate tasks include committing the finished Result work and addressing the overdue submain-to-main merge. With the test runner and error model resolved, attention turns to := type inference, finalizing diagnostics, and drafting example programs. The roadmap emphasizes that a language release without examples isn't much of a release, so now with most blockers cleared, crafting examples is a feasible next move.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-04-04

Cx Dev Log — 2026-03-31

COMMENTERTHE9 — Thu, 02 Apr 2026 00:06:07 +0000

Nothing shipped today. No compiler changes, no spec updates, no runtime work. The only commits in the last 24 hours were automated documentation: yesterday's blog post on site and the daily log branch for March 30. The working tree is clean across all branches.

This is the first fully idle day in a while, so it is worth taking stock of where things actually stand.

The submain gap, day five

The submain branch is still 4 commits ahead of main, unchanged since March 27. Those commits represent real, landed work:

Wrapping arithmetic enforcement
Phase 10 while loop lowering
UTF-8 string encoding decision locked
Semicolon rule refinement

All four are meaningful. The while loop lowering is backend progress. The wrapping arithmetic commit tightens numeric semantics. The UTF-8 and semicolon commits are spec-level decisions that close hard blockers and unblock downstream work.

None of it is on main yet. The merge has been predicted every day since March 27 and has not happened. The roadmap versions have diverged further: main is on v4.7, submain is on v4.6, and there is a v4.8 floating on an unmerged daily-log branch. Each day the gap sits, the docs/frontend/ROADMAP.md conflict gets slightly worse. It is not a crisis, but it is accumulating friction for no clear reason.

Hard blockers holding steady

The test runner and assert infrastructure have now gone eight consecutive days with no movement. Same for the Result error model. Both are listed as hard blockers. Both keep getting predicted as "next" and keep not happening.

To be clear, these are not blocked by technical dependencies. The spec decisions that needed to land first (UTF-8, semicolons) have landed, at least on submain. The test runner needs implementation work: a way to discover and run test functions, and a basic assert mechanism. The error model needs a design decision on Result semantics and then implementation. Neither is waiting on anything except someone sitting down and doing it.

Matrix status

78/78, unchanged. The frontend test matrix has been stable for over a week now. This is good in the sense that nothing is regressing, but it also reflects the lack of new work. New features or parser changes would be expected to temporarily bump or stress the matrix. Flat stability for this long just means nothing is moving.

What is next

The same list as yesterday, honestly:

Merge submain to main. The most straightforward action item. Four commits, one known roadmap conflict. Should be a 10-minute task.
Test runner and assert. Hard blocker, eight days deferred. This is the thing that would most change the project's development velocity if it landed.
Error model. Another hard blocker with extended inactivity.
Backend work. If/else lowering and struct layout are the natural continuation of the backend progress that already landed on submain.

Yesterday's predictions all missed. None of them happened. Today had zero language development activity. Whether tomorrow breaks the pattern or extends it will say a lot about the project's current momentum.

Follow the Cx language project:

Website: cx-lang.com
GitHub: github.com/COMMENTERTHE9/Cx_lang
Dev.to: dev.to/commenterthe9
Bluesky: thecomment.bsky.social
Twitter/X: @commenterthe9

Originally published at https://cx-lang.com/blog/2026-03-31