1
0
0
0
Hashtag
#compiler
Advertisement · 728 × 90
Whee. Compiler stage3 now passes all tests that stage1 and stage2 do, when running the tests via the IR emulator.
Time to start improving the IR, allocating registers, and implementing a backend to generate "real" code from the IR.
#Projects #Compiler
0
0
1
0
When Verified Source Lies I deployed a staking vault on Sepolia and got it verified on Etherscan with a green checkmark. The source code contains a storage write that does not exist in the compiled...
#smart-contracts #solidity #blockchain-security #ethereum #cybersecurity […]
0
0
0
0
This is patch #308
#OpenSource #Wave #Compiler #Patch
blog.wave-lang.dev/patch-308-pr...
1
0
0
0
git commit history for a couple changes tidying up the tree and splitting ir-types.spl into ir-instructions.spl and ir-blocks.spl
Blergh. Did a little tidying up, made a bigger mess, chased down the tiny one-line change that broke everything and hid in the noise, and put it all back together again.
Good: Everything's tidier.
Bad: Did not actually do the thing I set out to do this afternoon.
#Projects #Compiler
0
0
0
0
¿
Abstraction:
It removes the need for
manual __syncthreads() calls,
as #compiler automatically
manages #thread-synchronization
and #memory-movement.
0
0
0
0
Out Nerded The Source Code
Out Nerded The Source Code
#programming #Parenting #compiler #sourcecode #Family
programmerhumor.io/programming-memes/out-ne...
1
0
1
0
Spent a few days playing with the game of life program, fixed a lot of bugs in the language doing so. I should make more projects like this to stress test the language, any ideas for what else I should try coding?
#compiler #programming #raylib
6
0
0
0
Managed to build a cheeky little game of life simulator in my programming language!
#programming #compiler #raylib
4
0
1
0
A snippet of my programming language showing anonymous structs, multiple return values, and tuples ``` fn multiple_returns(): struct { u32, u32 } { return { 6, 7 } } //accept as anonymous struct fn foo(struct { a: u32, b: u32}) { println(a) println(b) } //accept as tuple fn bar(tup: struct { u32, u32 }) { println(tup.0) println(tup.1) } fn main(): u32 { let x = multiple_returns() foo(x) bar(x) return 0 } ```
Anonymous structs have blown open a whole new slew of features. Multiple return values and tuples basically for free
#compiler #programming
3
1
0
0
Wave v0.1.8-pre-beta is now released!
#OpenSource #Wave #Compiler #Release
blog.wave-lang.dev/wave-languag...
1
0
0
0
A snippet of code in my programming language showing coercion between a named struct and an unnamed struct, as well as promotion of an anonymous struct's fields to the containing struct: ``` struct Foo { { a: u32, b: u32 } } struct Pair { a: u32, b: u32 } fn foo({a: u32, b: u32}, c: u32) { println(a, b, c) } fn main(): u32 { let pair = Pair { 1, 2 } foo(pair, 3) //named struct coerced to anonymous struct let f = Foo { pair } println(f.a) println(f.b) return 0 } ```
The output: ``` 1, 2, 3 1 2 ```
Been noodling on how my language will handle anonymous structs. They're not done yet but I think they'll be pretty loose, able to coerce between compatible named structs. Plus they'll basically act like tuples once you can create anonymous struct literals, which is nice!
#programming #compiler
1
0
0
0
Compiler directives give you fine‑grained control over the build process. Use #Pragma to toggle debug‑only code, profile performance hotspots, or conditionally compile for specific platforms (Desktop, Web, Mobile). Do you use any in your projects?
#Compiler #Programming #BuildOptimization
0
0
0
0
#Development #Releases
Vite 8.0 is out · It ships Rolldown for up to 10–30x faster builds ilo.im/16bd5y by Vite
_____
#Vite #Tooling #Builder #Bundlers #Compiler #NodeJS #Rust #WebDev #Frontend
0
0
0
0
0
0
0
0
Two files in my language showing a barebones gameboy CPU and raylib draw loop with the gameboy window running, showing a blank screen
Getting to the point where I can write semi-serious programs in my language. It's a great way to find a bunch of subtle bugs and missing functionality. E.g. here's a ~totally functioning~ gameboy emulator
#programming #compiler #raylib
6
0
1
0
A program in my language showing function overloads: ``` struct Vec2 { x: u32, y: u32 } struct Vec3 { x: u32, y: u32, z: u32 } fn add(a: Vec2, b: Vec2): Vec2 { return Vec2 { a.x + b.x, a.y + b.y } } fn add(a: Vec3, b: Vec3): Vec3 { return Vec3 { a.x + b.x, a.y + b.y, a.z + b.z } } fn main(): u32 { let v2a = Vec2 { 3, 2 } let v2b = Vec2 { 4, 3 } let v2c = add(v2a, v2b) println(v2c) let v3a = Vec3 { 3, 2, 1 } let v3b = Vec3 { 2, 1, 1 } let v3c: Vec3 = add(v3a, v3b) println(v3c) return 0 } ```
The output of the program: ``` { 7, 5 } { 5, 3, 2 } ```
Had to implement some name mangling when emitting functions to lay the groundwork for interfaces, and I noticed this gave me function overloads for free. Take that, C!
#compiler #programming
0
0
0
0
#Development #Explainers
The CodePen Compiler · The CodePen 2.0 editor has a whole new brain ilo.im/16bcg0 by CodePen
_____
#CodePen #CodeEditor #Compiler #Builder #Website #WebDev #Frontend #HTML #CSS #JavaScript
1
0
0
0
Starting to get some credible looking (unoptimized) IR out of the stage3 compiler. Physical registers are dollar-prefixed, virtual registers percent-prefixed. The comments on the basic blocks are human-friendly tags to help see which part of the codegen they came from.
#Projects #Compiler
2
1
1
0
2
0
0
0
A snippet of my programming language showing optionals and early returns on optionals: ``` fn maybe(b: bool): ?u32 { if (b) return 10 return none } fn opt_return(b: bool): ?u32 { let x = maybe(b) println(x?) //if x is none, return here, else print the value of x (10) println("x was some!") return x } fn main(): u32 { let x = opt_return(true) if (x) |value| { println(value + 10) } else println("x was none") let y = opt_return(false) if (y) |value| { println(value + 10) } else println("y was none") return 0 } ```
The output of the program: ``` 10 x was some! 20 y was none ```
It's all coming together. Now I have unions I can implement the optional type ?T which is just a tagged union. In addition I could implement rust style try-unwrap of optionals basically for free with all the parts I have!
Here opt_return only prints x if it's some, else it returns early!
#compiler
3
0
0
0
my weekend warrior project #zigttp now has a web site (🚧):
zigttp.timok.deno.net
🎉🚀
#ziglang #typescript #runtime and #compiler
3
0
1
0
Now with the fancy struct syntax, implementing tagged unions was relatively easy. Also got rid of all those pesky semicolons messing up the place
#compiler
1
0
0
0
Using my MXVM Interpreter/Compiler to produce x86_64 Assembly language with AT&T syntax, then using att2intel to convert from AT&T to Intel. #asm #compiler
2
0
0
0
Xcode Swift: “expression too complex to resolve…”
So, you’re saying the language is non-deterministic and too convulsed even for a compiler… Gotcha!
My bane in using Swift. You have to jump through hoops and invent non-existent curses to resolve the error.
#apple #swift #xcode #compiler #failure
0
0
0
0
Blew apart my struct and function parsing to allow default values and named arguments. Pretty swanky imo
#compiler
1
0
0
0
Not sure it's the greatest use of it but the new `with` statement works nicely with raylib 😅
#raylib #compiler
1
0
1
0
A snippet of my programming language showing the defer statement: ``` fn main() { let f = os::open_file("test.txt"); defer os::close(f); for _ in 0..15 { os::write(f, "Hello once again from osmium!\n"); } } ```
A snippet from my programming language showing the same code but using a `with` statement: ``` fn main() { with let f = os::open_file("test.txt"); { println("closing file!"); os::close(f); } { for _ in 0..15 { os::write(f, "Hello once again from osmium!\n"); } println("done writing!"); } println("end of main!"); } ```
The output of the with statement variant showing the order in which things are run: ``` done writing! closing file! end of main! ```
Added a defer statement to my language, but I didn't like how the resource acquisition and disposal had to be separated. So I added a with statement that just desugars to defer, and I kinda like it!
#compiler
3
0
0
0
A program in my programming language showing pointer allocation and illegal freeing: ``` fn bad(ptr: &u32) { free ptr; } fn main() { let x = new u32; free x; let i = 10; let p = &i; free p; } ```
The error messages from compiling the program: ``` Error: Cannot free a pointer with lifetime `Param` at src\main\resources\examples\memory.os:2:5 2 | free ptr; | ^^^^^^^^^ Error: Cannot free a pointer with lifetime `Stack` at src\main\resources\examples\memory.os:11:5 11 | free p; | ^^^^^^^ ```
Starting on the memory management for my language. Nothing fancy but just a few more guard rails than C. Every pointer has an "origin": Stack, Param, Heap, or Global. Only Heap can be freed, and Stack can't be returned from functions.
Maybe this will cause problems but we'll see!
#compiler #llvm
1
0
1
0