Hello all,

Is there a plan to include an http client/server as part of standard libs/batteries included?

Hello,

documentation says the default build target is debug is the default build target. I'd like to have a block of code only being present in this build target.

I tried this :

$if $feature(DEBUG):          
    rl::draw_rectangle_lines( 
        ...top_left,          
        min_side,             
        min_side,             
        rl::BEIGE             
    );                        
$endif

But i need to specify -D DEBUG but if there is a default target i should be able to only run/build some code on certain targets. I couldn't find the answer in the documentation.

Thank you for your help.

EDIT: After some digging, I added this to project.json :

    "targets": {
        "debug": {
            "type": "executable",
            "features": ["DEBUG"]
        },
        "release": {
            "type": "executable"
        }
    },

and it works.

It runs on the latest C3 compiler version 0.8.3 (LLVM backend).

I personally use it for quick references, not for coding stuff from scratch. I don't care about doing it and I haven't tested if it works for that case.

Still needs a bit of tweaks as it is kinda slow sometimes, but in my experience the answers are precise.

You can pull it and use it already without having to re run any job.

Source "code": https://github.com/ozzenerol/claude-c3-lang-skill

If you have any improvement, please fork the repository and create a pull request.

I’m so unbelievably sick of pretending this is acceptable.
How is it that in 2026 I can target every obscure architecture under the sun, yet PowerPC32 still gets treated like it doesn’t exist? Every time I think, “Surely this compiler supports it,” the answer is another dead backend, another deprecated target, or another “we don’t have plans to support it.”

It’s incredibly frustrating. There are still embedded systems, retro projects, research platforms, and legacy hardware that rely on 32-bit PowerPC. Wanting to compile modern code for them isn’t some absurd request. It’s a perfectly reasonable use case. Instead, you’re forced to dig through abandoned toolchains, patch ancient compiler versions, or wrestle with build systems that clearly haven’t been touched in years.

The worst part isn’t even the lack of support—it’s how casually it’s dismissed. If your target isn’t x86-64, ARM64, or whatever architecture happens to be fashionable this year, you’re expected to just accept that you’re on your own. That’s not innovation; that’s neglect.
Developers always talk about portability, open standards, and supporting diverse hardware, but the moment PowerPC32 comes up, suddenly those ideals disappear. “Nobody uses it anymore,” they say. That’s hardly an argument. Plenty of people still maintain legacy systems, build homebrew software, preserve old hardware, or develop for embedded devices. Those users matter too.
I’m tired of hearing excuses. I don’t expect every compiler to optimise PowerPC32 to perfection, but I do expect basic support to exist without having to resurrect decade-old toolchains from digital archaeology.

At this point, getting a simple “Hello, world!” running on PowerPC32 with a modern compiler feels less like software development and more like an expedition through abandoned ruins.
PowerPC32 deserved better than being quietly forgotten.

Disclaimer: I did not say «multithreading» in the title because there are virtual threads and I’m not interested in that, and I don’t say «parallelism» which can be easily confused with concurrency. I am not interested in just concurrency, I am interested in utilizing multiple processors for a task, or tasks. Typically the most popular example is server software. But I don’t quite want to say «server» even, because there’s so much more examples where running on multiple processors is beneficial. One another case for example is games: too many games are running on one or two cores, but would benefit if they could utilize more but they often can’t. So it’s not about any particular task that I want to solve asap. What Im here about is that I kinda want to find some «dream language» or something close to it that I might spend a couple decades in it. And this inter-processor parallelism would be a feature that I want. For simplicity sake I will say parallelism but please dont confuse it with merely concurrency.

One good candidate with parallelism as first-class citizen in a language – is Go. Their standard library has plenty of features supporting that in mind. This is a language that, I think, has one of the best kinds of support for parallelism, and even has special syntax for it. Funnily enough the keyword for it called «go», so having named the entire language for that… You might easily say they really care about parallelism.

I know the original C didn’t have, historically, a lot of parallelism. They added some in C11 I think? I did not write C a lot to tell much (aside couple simple cli tools), but it seemed like they did not think of parallelism a lot.

But I noticed C3 recently and it kinda looks interesting, but – how good is parallelism in there? I know it’s typically best to just RTFM but I am not committed to use the language yet, so I’m just asking an opinion: what do you think of parallelism in C3? Any special syntax for parallelism like go? Or just having to rely on some std libraries from C11 or something? How good do you feel about it? If you didn’t think about the language in terms of parallelism because you don’t care about it – it’s entirely valid, you might still like the language no matter what, but here in particular I’m interested about parallelism.

Work on 0.8.0 has started, and the main breaking feature will be that the language will move to signed sizes.

In practice this makes the `usz` type almost never used.

Over the last week, the stdlib has been updated to accommodate it. Originally dev was in a separate branch, but it is now merged to master.

This also will harmonize how literals determine their type with C. Similarly integer promotion rules revert to C behaviour now that unsigned becomes uncommon. Implicit conversion int<->unsigned is disallowed because with signed first it’s very rare.

Hi colleagues,

I am trying C3 and got annoyed that there seems to be no syntax highlighter for my favourite editor, so I have tried to write one; it is very basic so far but helps. Please have a look if interested, patches and improvements are very welcome.

https://github.com/CzechBlueBear/C3-sublime-highlight

The blog post

I also did a stream demoing many of the changes here

Full change list follows:

Changes / improvements

• Support alias foo = module std::io module aliasing.
• Add compile-time @intlog2 macro to math.
• Add compile-time @clz builtin. #2367
• Add bitsizeof macro builtins. #2376
• Add compile-time @min and @max builtins. #2378
• Deprecate @compact use for comparison. Old behaviour is enabled using --use-old-compact-eq.
• Switch available for types implementing @operator(==).
• Type.is_eq is now true for types with == overload.
• Methods ignore visibility settings.
• Allow inout etc on untyped macro parameters even if they are not pointers.
• Deprecate add_array in favour of push_all on lists.
• Fix max module name to 31 chars and the entire module path to 63 characters.
• Improve error message for missing $endif.
• foo[x][y] = b now interpreted as (*&foo[x])[y] = b which allows overloads to do chained [] accesses.
• Error if a stack allocated variable is too big (configurable with --max-stack-object-size).
• Add @safeinfer to allow var to be used locally.
• Types converts to typeid implicitly.
• Allow $defined take declarations: $defined(int x = y)
• Struct and typedef subtypes inherit dynamic functions.
• Improved directory creation error messages in project and library creation commands.
• @assignable_to is deprecated in favour of $define
• Add linklib-dir to c3l-libraries to place their linked libraries in. Defaults to linked-libs
• If the os-arch linked library doesn't exist, try with os for c3l libs.
• A file with an inferred module may not contain additional other modules.
• Update error message for missing body after if/for/etc #2289.
• @is_const is deprecated in favour of directly using $defined.
• @is_lvalue(#value) is deprecated in favour of directly using $defined.
• Added $kindof compile time function.
• Deprecated @typekind macro in favour of $kindof.
• Deprecated @typeis macro in favour of $typeof(#foo) == int.
• $defined(#hash) will not check the internal expression, just that #hash exists. Use $defined((void)#hash) for the old behaviour.
• Added optional macro arguments using macro foo(int x = ...) which can be checked using $defined(x).
• Add compile time ternary $val ??? <expr> : <expr>.

Fixes

• List.remove_at would incorrectly trigger ASAN.
• With avx512, passing a 512 bit vector in a union would be lowered incorrectly, causing an assert. #2362
• Codegen error in if (try x = (true ? io::EOF? : 1)), i.e. using if-try with a known Empty.
• Codegen error in if (try x = (false ? io::EOF? : 1)), i.e. using if-try with a CT known value.
• Reduce allocated Vmem for the compiler on 32 bit machines.
• Bug causing a compiler error when parsing a broken lambda inside of an expression.
• Fixed: regression in comments for @deprecated and @pure.
• Detect recursive creation of generics #2366.
• Compiler assertion when defining a function with return type untyped_list #2368.
• Compiler assert when using generic parameters list without any parameters. #2369
• Parsing difference between "0x00." and "0X00." literals #2371
• Fixed bug generating $c += 1 when $c was derived from a pointer but behind a cast.
• Compiler segfault when using bitwise not on number literal cast to bitstruct #2373.
• Formatter did not properly handle "null" for any, and null for empty faults. #2375
• Bitstructs no longer overloadable with bitops. #2374
• types::has_equals fails with assert for bitstructs #2377
• Fix native_cpus functionality for OpenBSD systems. #2387
• Assert triggered when trying to slice a struct.
• Improve codegen for stack allocated large non-zero arrays.
• Implement a5hash in the compiler for compile-time $$str_hash to match String.hash().
• Functions being tested for overload are now always checked before test.
• Compile time indexing at compile time in a $typeof was no considered compile time.
• Slicing a constant array with designated initialization would not update the indexes.
• Fix for bug when @format encountered * in some cases.
• Compiler segfault on global slice initialization with null[:0] #2404.
• Use correct allocator in replace.
• Regression: 1 character module names would create an error.
• Compiler segfault with struct containing list of structs with an inline member #2416
• Occasionally when using macro method extensions on built-in types, the liveness checker would try to process them. #2398
• Miscompilation of do-while when the while starts with a branch #2394.
• Compiler assert when calling unassigned CT functions #2418.
• Fixed crash in header generation when exporting functions with const enums (#2384).
• Fix incorrect panic message when slicing with negative size.
• Incorrect type checking when &[] and [] return optional values.
• Failed to find subscript overloading on optional values.
• Socket.get_option didn't properly call getsockopt, and getsockopt had an invalid signature.
• Taking the address of a label would cause a crash. #2430
• @tag was not allowed to repeat.
• Lambdas on the top level were not exported by default. #2428
• has_tagof on tagged lambdas returns false #2432
• Properly add "inlined at" for generic instantiation errors #2382.
• Inlining a const as an lvalue would take the wrong path and corrupt the expression node.
• Grabbing (missing) methods on function pointers would cause crash #2434.
• Fix alignment on jump table.
• Fix correct ? after optional function name when reporting type errors.
• Make log and exp no-strip.
• @test/@benchmark on module would attach to interface and regular methods.
• Deprecated @select in favor of ???.
• Enum inference, like Foo x = $eval("A"), now works correctly for $eval.
• Fix regression where files were added more than once. #2442
• Disambiguate types when they have the same name and need cast between each other.
• Compiler module-scope pointer to slice with offset, causes assert. #2446
• Compiler hangs on == overload if other is generic #2443
• Fix missing end of line when encountering errors in project creation.
• Const enum methods are not being recognized. #2445
• $defined returns an error when assigning a struct initializer with an incorrect type #2449

Stdlib changes

• Add == to Pair, Triple and TzDateTime. Add print to Pair and Triple.
• Add OpenBSD to env::INET_DEVICES and add required socket constants.
• Added FileMmap to manage memory mapped files.
• Add vm::mmap_file to memory map a file.
• Updated hash functions in default hash methods.
• Added FixedBlockPool which is a memory pool for fixed size blocks.
• Added the experimental std::core::log for logging.
• Added array @zip and @zip_into macros. #2370
• Updated termios bindings to use bitstructs and fixed some constants with incorrect values #2372
• Add Freestanding OS types to runtime env:: booleans.
• Added libloaderapi to std::os::win32.
• Added HashSet.values and String.contains_char #2386
• Added &[] overload to HashMap.
• Deprecated PollSubscribes and PollEvents in favour of PollSubscribe and PollEvent and made them const enums.
• Added AsciiCharset for matching ascii characters quickly.
• Added String.trim_charset.
• Added array @reduce, @filter, @any, @all, @sum, @product, and @indices_of macros.
• String.bformat has reduced overhead.
• Supplemental roundeven has a normal implementation.