C3 0.7.8 release: struct splatting and vector swizzle initialization
https://www.reddit.com/r/programming/comments/1pewvug/c3_078_release_struct_splatting_and_vector/

<!-- SC_OFF -->C3 is a language designed as an evolution of C, without retaining strict backwards compatibility, but excellent interop with C. This version brings - among other things: struct splatting (some_call(...a_struct, 1, 2)) and vector swizzle initialization (int[] x = { .xy = 3, .z = 5 }). Together with other improvements and fixes. Full change log: Changes / improvements Improve multiline string parser inside compiler #2552. Missing imports allowed if module @if evaluates to false #2251. Add default exception handler to Win32 #2557. Accept "$schema" as key in project.json #2554. Function referencing in @return? for simplified fault declarations. Check @return? eagerly #2340. Enums now work with membersof to return the associated values. #2571 Deprecated SomeEnum.associated in favour of SomeEnum.membersof Refactored @simd implementation. Improve error message for Foo{} when Foo is not a generic type #2574. Support @param directives for ... parameters. #2578 Allow splatting of structs. #2555 Deprecate --test-nocapture in favour of --test-show-output #2588. Xtensa target no longer enabled by default on LLVM 22, Compile with -DXTENSA_ENABLE to enable it instead Add float[] x = { .xy = 1.2, .z = 3.3 } swizzle initialization for vectors. #2599 Support int $foo... arguments. #2601 Add musl support with --linux-libc=musl. Fixes Foo.is_eq would return false if the type was a typedef and had an overload, but the underlying type was not comparable. Remove division-by-zero checks for floating point in safe mode #2556. Fix division-by-zero checks on a /= 0 and b /= 0f #2558. Fix fmod a %= 0f. Regression vector ABI: initializing a struct containing a NPOT vector with a constant value would crash LLVM. #2559 Error message with hashmap shows "mangled" name instead of original #2562. Passing a compile time type implicitly converted to a typeid would crash instead of producing an error. #2568 Compiler assert with const enum based on vector #2566 Fix to Path handling c:\foo and \home parent. #2569 Fix appending to c:\ or \ #2569. When encountering a foreach over a ZString* it would not properly emit a compilation error, but hit an assert #2573. Casting a distinct type based on a pointer to an any would accidentally be permitted. #2575 overflow_* vector ops now correctly return a bool vector. Regression vector ABI: npot vectors would load incorrectly from pointers and other things. #2576 Using defer catch with a (void), would cause an assertion. #2580 Fix decl attribute in the wrong place causing an assertion. #2581 Passing a single value to @wasm would ignore the renaming. *(int*)1 incorrectly yielded an assert in LLVM IR lowering #2584. Fix issue when tests encounter a segmentation fault or similar. With project.json, when overriding with an empty list the base settings would still be used. #2583 Add sigsegv stacktrace in test and regular errors for Darwin Arm64. #1105 Incorrect error message when using generic type that isn't imported #2589 String.to_integer does not correctly return in some cases where it should #2590. Resolving a missing property on a const enum with inline, reached an assert #2597. Unexpected maybe-deref subnoscript error with out parameter #2600. Bug on rethrow in return with defer #2603. Fix bug when converting from vector to distinct type of wider vector. #2604 $defined(hashmap.init(mem)) causes compiler segfault #2611. Reference macro parameters syntax does not error in certain cases. #2612 @param name parsing too lenient #2614. Stdlib changes Add CGFloat CGPoint CGSize CGRect types to core_foundation (macOS). Add NSStatusItem const enum to ns module (macOS). Add NSWindowCollectionBehavior NSWindowLevel NSWindowTabbingMode to ns module (macOS). Add ns::eventmask_from_type function to objc (macOS). Deprecate objc enums in favour of const

inline enums backed by NS numerical types, and with the NS prefix, to better align with the objc api (macOS). Deprecate event_type_from function in favour of using NSEvent directly, to better align with the objc api (macOS). Add unit tests for objc and core_foundation (macOS). Make printing typeids give some helpful typeid data. Add NSApplicationTerminateReply to ns module (macOS). Add registerClassPair function to objc module (macOS). Somewhat faster BigInt output. Cache printf output. <!-- SC_ON --> submitted by /u/Nuoji (https://www.reddit.com/user/Nuoji)
[link] (https://c3-lang.org/blog/jingle-bells,-c3-0-7-8-/) [comments] (https://www.reddit.com/r/programming/comments/1pewvug/c3_078_release_struct_splatting_and_vector/)

The only simple geometric constraint solver on the internet
https://www.reddit.com/r/programming/comments/1pexv0f/the_only_simple_geometric_constraint_solver_on/

<!-- SC_OFF -->Now you can understand how 3D CAD works on the inside. <!-- SC_ON --> submitted by /u/felzsirostej (https://www.reddit.com/user/felzsirostej)
[link] (https://github.com/kasznar/geometric-constraint-solver) [comments] (https://www.reddit.com/r/programming/comments/1pexv0f/the_only_simple_geometric_constraint_solver_on/)

Why ID Format Matters More Than ID Generation (Lessons from Production)
https://www.reddit.com/r/programming/comments/1pf02wp/why_id_format_matters_more_than_id_generation/

submitted by /u/piljoong (https://www.reddit.com/user/piljoong)
[link] (https://piljoong.dev/posts/distributed-id-generation-complicated/) [comments] (https://www.reddit.com/r/programming/comments/1pf02wp/why_id_format_matters_more_than_id_generation/)

Fizz Buzz in 4 lines of CSS
https://www.reddit.com/r/programming/comments/1pf41xp/fizz_buzz_in_4_lines_of_css/

submitted by /u/brightlystar (https://www.reddit.com/user/brightlystar)
[link] (https://mastodon.social/@susam/115668571178604230) [comments] (https://www.reddit.com/r/programming/comments/1pf41xp/fizz_buzz_in_4_lines_of_css/)

Prometheus woke me up. I decided to get to know it better
https://www.reddit.com/r/programming/comments/1pf476p/prometheus_woke_me_up_i_decided_to_get_to_know_it/

submitted by /u/Helpful_Geologist430 (https://www.reddit.com/user/Helpful_Geologist430)
[link] (https://cefboud.com/posts/prometheus-monitoring-alertmanager-internals-tsdb/) [comments] (https://www.reddit.com/r/programming/comments/1pf476p/prometheus_woke_me_up_i_decided_to_get_to_know_it/)

Leaving Intel
https://www.reddit.com/r/programming/comments/1pfhhah/leaving_intel/

<!-- SC_OFF -->He's accomplished so much in only 3.5 years. I wonder where he's going next? Any guesses? <!-- SC_ON --> submitted by /u/ThanksMorningCoffee (https://www.reddit.com/user/ThanksMorningCoffee)
[link] (https://www.brendangregg.com/blog//2025-12-05/leaving-intel.html) [comments] (https://www.reddit.com/r/programming/comments/1pfhhah/leaving_intel/)

Some guy played GTA 5 with his car (C, golang, Python)
https://www.reddit.com/r/programming/comments/1pflbe6/some_guy_played_gta_5_with_his_car_c_golang_python/

submitted by /u/SomewhereRough_ (https://www.reddit.com/user/SomewhereRough_)
[link] (https://youtu.be/W1cvxAJ-fYQ) [comments] (https://www.reddit.com/r/programming/comments/1pflbe6/some_guy_played_gta_5_with_his_car_c_golang_python/)

Polynomial roots visualisation inspired by 2swap's video on the quintic
https://www.reddit.com/r/programming/comments/1pflitt/polynomial_roots_visualisation_inspired_by_2swaps/

<!-- SC_OFF -->Upon watching this 2swap video (https://youtu.be/9HIy5dJE-zQ) I thought the visuals were incredibly mesmerising and thus created my own visualisation program with which I could play around with different coefficients and degrees. The GitHub readme page discusses several implementation details and optimisations to enable real-time rendering of the point cloud, including using OpenCL kernels to parallelise evaluation. Might have gone a little overboard and added animation facilities to this. <!-- SC_ON --> submitted by /u/therealoranges (https://www.reddit.com/user/therealoranges)
[link] (https://github.com/TheRealOrange/acidvis) [comments] (https://www.reddit.com/r/programming/comments/1pflitt/polynomial_roots_visualisation_inspired_by_2swaps/)

SystemSketcher. A tools where you can design system architecture and prepare for interview.
https://www.reddit.com/r/programming/comments/1pfn5cx/systemsketcher_a_tools_where_you_can_design/

<!-- SC_OFF -->Hey everyone, I’ve been preparing for system design interviews and kept wishing there was a simple way to sketch architectures and get instant feedback. Checkout SystemSketcher, a free web tool where you can: Sketch system diagrams quickly Use keyboard shortcuts to speed up drawing Enter “interview mode” and get AI to act as an interviewer Explain your design while the AI checks gaps, asks follow-up questions, and summarizes your solution Not selling anything, just looking for feedback from people who actually do system design. If you’re willing to try it out and tell me what’s confusing / missing / broken, I’d really appreciate it. Thanks! <!-- SC_ON --> submitted by /u/lalatputih (https://www.reddit.com/user/lalatputih)
[link] (https://systemsketcher.com/) [comments] (https://www.reddit.com/r/programming/comments/1pfn5cx/systemsketcher_a_tools_where_you_can_design/)

Google and Youtube advanced search techniques while learning totally new computer science concepts
https://www.reddit.com/r/programming/comments/1pfnqhl/google_and_youtube_advanced_search_techniques/

<!-- SC_OFF -->Wrote a blog while procastinating to learn ipv6. Completely unnoscripted. <!-- SC_ON --> submitted by /u/PrimaryWaste8717 (https://www.reddit.com/user/PrimaryWaste8717)
[link] (https://rbcrossley.github.io/post/google-and-youtube-search-techniques-for-learning-new-concepts/) [comments] (https://www.reddit.com/r/programming/comments/1pfnqhl/google_and_youtube_advanced_search_techniques/)

Built my first Interpreted language at 15
https://www.reddit.com/r/programming/comments/1pfqbkv/built_my_first_interpreted_language_at_15/

<!-- SC_OFF -->Hello everyone. I'm a 15-year-old developer and I just finished building Lento, an interpreted language in Go. https://github.com/caelondev/lento A bit of background: I have this hobby where whenever I learn a new programming language, I build an interpreter in it to really solidify my understanding. I find that creating an interpreter forces you to actually use almost everything a language has to offer—syntax, control flow, file I/O, REPL interactions, functions, data structures, type systems, memory management, and more. It's like a comprehensive exam that shows what you've truly learned, and it's been an incredible way to discover the strengths and quirks of each language I pick up. Lento is a tree-walk interpreter with a C-like syntax that includes the essential features you'd expect from a noscripting language: variables, functions with closures, control flow structures (if/else, loops, break/continue/return), arrays and objects, a full set of operators, and an interactive REPL. It's designed to be simple and fast, executing noscripts in microseconds. Building this has been eye-opening. Implementing the lexer, parser (using Pratt parsing for operator precedence), and the runtime environment taught me so much about how languages actually work under the hood. There's something really satisfying about writing code that reads and executes other code. I'd really appreciate any feedback from the community! Feel free to check it out, try the examples in the repo, and open issues if you spot any bugs or have suggestions for improvements. Since I'm still learning, any advice on parser design, language features, or performance optimizations would be incredibly valuable. Has anyone else used similar projects to learn programming concepts? I'd love to hear about your experiences! Thanks for checking it out! <!-- SC_ON --> submitted by /u/Adorable-Bee4127 (https://www.reddit.com/user/Adorable-Bee4127)
[link] (https://github.com/caelondev/lento) [comments] (https://www.reddit.com/r/programming/comments/1pfqbkv/built_my_first_interpreted_language_at_15/)

i created some simple(not actually) iso burner
https://www.reddit.com/r/programming/comments/1pfrbd8/i_created_some_simplenot_actually_iso_burner/

<!-- SC_OFF -->I've created this tool because im bored, and sick of limited linux iso burner tools with no persistence, and the command is to much sweat. so I've been plan to create some you know. like it. actually I've tested it out but im so completely dumb 😥😥, because instead of /dev/sdb is the -o i made it /dev/sdb3 🤦‍♀️🤦‍♀️🤦‍♀️🤦‍♀️🤦‍♀️🤦‍♀️. it would help if some y'all try it. and suggets what to add, and optimize in the next update. Happy Advance Christmas! <!-- SC_ON --> submitted by /u/Youre_Good_8111 (https://www.reddit.com/user/Youre_Good_8111)
[link] (https://github.com/JeckAsChristopher/MyISO) [comments] (https://www.reddit.com/r/programming/comments/1pfrbd8/i_created_some_simplenot_actually_iso_burner/)

Technical Writeup: Building an Ultra-Fast, Zero-Auth, Multi-Language Anagram API using C# ASP.NET Core & In-Memory Data
https://www.reddit.com/r/programming/comments/1pfue6n/technical_writeup_building_an_ultrafast_zeroauth/

<!-- SC_OFF -->Hey r/programming (https://www.reddit.com/r/programming), I’m releasing a 100% free and public API called Poocoo API, focusing on advanced word operations. While the service is simple, the core engineering challenge was achieving ultra-fast anagram search performance with a multi-language dataset. I wanted to share a technical writeup on how the anagram search was optimized, rather than just listing features. Technical Deep Dive: The Anagram Optimization Challenge The backend is built with C# ASP.NET Core, with all dictionary data held in-memory for minimal latency. The key to speed was preprocessing and indexing the words: Preprocessing: Instead of calculating character counts (or sorting) letters at runtime for every user request, I pre-sort and store a "canonical form" (an 'alphabetized signature') for every word in the dictionary. For example, the words "dog" and "god" both map to the signature "dgo". In-Memory Index: The entire dictionary is loaded into a fast in-memory structure (a Dictionary> or similar hash map) where the Key is the canonical signature and the Value is a list of all anagrams sharing that signature. Runtime Efficiency: When a user requests anagrams for a jumble of letters (e.g., "ellohworld"), the API only needs to: Generate the canonical signature of the input letters (dhlloorw). Perform one direct lookup in the in-memory index. Return the pre-calculated list of matching words. This approach guarantees O(1) complexity (after the initial signature generation), resulting in millisecond response times. API Use & Key Details Zero-Auth Policy: No API keys, tokens, or signup are needed. I wanted it to be plug-and-play for simple side projects. Multi-language Support: Dictionaries for English (EN), German (DE), French (FR), and Polish (PL). Example Anagram Search: https://api.poocoo.app/api/v1/words-from-letters?letters=hellloword The API also features a quick advanced filtering endpoint. I'm keen to hear your technical feedback on the optimization approach or any C# suggestions! Client Repo (Vanilla JS Demo): https://github.com/tjaworski997/poocoo.api.demo Live Demo (Test it yourself): https://tjaworski997.github.io/poocoo.api.demo/ <!-- SC_ON --> submitted by /u/VirtualPossibility75 (https://www.reddit.com/user/VirtualPossibility75)
[link] (https://github.com/tjaworski997/poocoo.api.demo) [comments] (https://www.reddit.com/r/programming/comments/1pfue6n/technical_writeup_building_an_ultrafast_zeroauth/)

LZAV 5.7: Improved compression ratio, speeds. Now fully C++ compliant regarding memory allocation. Benchmarks across diverse datasets posted. Fast Data Compression Algorithm (inline C/C++).
https://www.reddit.com/r/programming/comments/1pgc7sz/lzav_57_improved_compression_ratio_speeds_now/

submitted by /u/avaneev (https://www.reddit.com/user/avaneev)
[link] (https://github.com/avaneev/lzav) [comments] (https://www.reddit.com/r/programming/comments/1pgc7sz/lzav_57_improved_compression_ratio_speeds_now/)

One of Those Bugs
https://www.reddit.com/r/programming/comments/1pgd3jq/one_of_those_bugs/

submitted by /u/Commission-Either (https://www.reddit.com/user/Commission-Either)
[link] (https://daymare.net/blogs/one-of-those-bugs/) [comments] (https://www.reddit.com/r/programming/comments/1pgd3jq/one_of_those_bugs/)

[OSS] HashSmith – High-performance open-addressing hash tables for Java (SwissTable / Robin Hood)
https://www.reddit.com/r/programming/comments/1pgfatm/oss_hashsmith_highperformance_openaddressing_hash/

<!-- SC_OFF -->Hey everyone 👋 I've been experimenting with high-performance hash table implementations on the JVM and ended up creating HashSmith: What it is:
- A collection of open-addressing hash tables for Java
- Implementations based on Robin Hood probing and SwissTable-style layouts
- Focused on predictable performance and memory efficiency Highlights:
- JMH benchmarks comparing HashSmith vs JDK HashMap
- JOL-based memory footprint analysis
- Java 21, with vector-friendly layouts in mind (where applicable) I'd love feedback on:
- API design (does it feel “Java-ish”?)
- Benchmark methodology (anything obviously missing?)
- Edge cases/workloads you'd like to see tested
- How this could be improved or extended – features, variants, or trade-offs worth exploring next Thanks! <!-- SC_ON --> submitted by /u/Charming-Top-8583 (https://www.reddit.com/user/Charming-Top-8583)
[link] (https://github.com/bluuewhale/HashSmith) [comments] (https://www.reddit.com/r/programming/comments/1pgfatm/oss_hashsmith_highperformance_openaddressing_hash/)

Authentication Explained: When to Use Basic, Bearer, OAuth2, JWT & SSO
https://www.reddit.com/r/programming/comments/1pgfxs1/authentication_explained_when_to_use_basic_bearer/

submitted by /u/javinpaul (https://www.reddit.com/user/javinpaul)
[link] (https://javarevisited.substack.com/p/system-design-basics-authentication) [comments] (https://www.reddit.com/r/programming/comments/1pgfxs1/authentication_explained_when_to_use_basic_bearer/)

Surface Tension of Software: why systems hold together
https://www.reddit.com/r/programming/comments/1pgis1n/surface_tension_of_software_why_systems_hold/

<!-- SC_OFF -->Some systems manage to stay coherent as they grow, while others seem to lose their shape almost immediately. I’ve been thinking about this through a metaphor from physics: surface tension — the quiet force that helps structures keep themselves together. Here’s a short reflection on how that idea maps to software systems and why certain architectures resist chaos better than others. https://iamstelios.com/blog/surface-tension-of-software/ <!-- SC_ON --> submitted by /u/gonefreeksss (https://www.reddit.com/user/gonefreeksss)
[link] (https://iamstelios.com/blog/surface-tension-of-software/) [comments] (https://www.reddit.com/r/programming/comments/1pgis1n/surface_tension_of_software_why_systems_hold/)

Spinlocks vs. Mutexes: When to Spin and When to Sleep
https://www.reddit.com/r/programming/comments/1pgjrbd/spinlocks_vs_mutexes_when_to_spin_and_when_to/

<!-- SC_OFF -->Every Lock Costs You Something <!-- SC_ON --> submitted by /u/Extra_Ear_10 (https://www.reddit.com/user/Extra_Ear_10)
[link] (https://howtech.substack.com/p/spinlocks-vs-mutexes-when-to-spin) [comments] (https://www.reddit.com/r/programming/comments/1pgjrbd/spinlocks_vs_mutexes_when_to_spin_and_when_to/)

KOllector - Publishing KOReader Highlights
https://www.reddit.com/r/programming/comments/1pgkdmr/kollector_publishing_koreader_highlights/

submitted by /u/iamstonecharioteer (https://www.reddit.com/user/iamstonecharioteer)
[link] (https://tech.stonecharioteer.com/posts/2025/kollector/) [comments] (https://www.reddit.com/r/programming/comments/1pgkdmr/kollector_publishing_koreader_highlights/)