The Fuzion Language
@fuzionlang.bsky.social
A language that unifies concepts to improve productivity and to use tools for performance and correctness.
Fuzion July update is out: Work on safe concurrency continues: Multi-thread mutate effects provide exclusive access to mutable variables. No accidental racy accesses, no undefined behavior. All the details: fuzion-lang.dev/news/news_064
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
Safety for concurrency finally takes shape for Fuzion @fuzion@ŧypes.pl: An easy answer to concurrency issues is to rely on libraries that implement inter-thread communication mechanisms like channels. 🧵1/9…
Fuzion June update: Fearless concurrency with effects —thread-local mutate or thread-safe blocking_mutate— code can be written for both, efficient single-thread use or synchronized concurrent use. All the details: fuzion-lang.dev/news/news_063
Fuzion May update: In April, an important issue with effects was solved: Where do default instances come from? A big bang singularity that instates them when the system starts! And an effect wormhole passes effects on to other threads. The details: fuzion-lang.dev/news/news_062
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
The Fuzion language April update is out. A focus of the current work on Fuzion is stabilizing the code base, removing engineering debt and fixing bugs while preparing for the development of real-time APIs through tool and API support. All the details: fuzion-lang.dev/news/news_061
The Fuzion language March update is out. Putting Fuzion code in production by switching to fzweb as the webserver behind fuzion-lang.dev is the biggest step ahead. A number of optimizations and base lib additions supported this step. All the details: fuzion-lang.dev/news/news_060
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
A major milestone for the Fuzion language has been reached: fzweb, the Fuzion port of the web server behind fuzion-lang.dev, has gone live earlier this week replacing the Java-based webserver. fzweb is, of course, also open source and available on github: github.com/tokiwa-softw...
GitHub - tokiwa-software/fzweb
Contribute to tokiwa-software/fzweb development by creating an account on GitHub.
github.com
The Fuzion February news are out! We are focusing our work on exciting performance improvements and cleanup work towards the Go Live of fzweb, a re-implementation in Fuzion of the web server behind fuzion-lang.dev. fuzion-lang.dev/news/news_059
fuzion-lang.dev
The Fuzion January news are out. Improvements include new syntax for anonymous inner features and a number of performance enhancements and code cleanup. All the details: fuzion-lang.dev/news/news_058
fuzion-lang.dev
#AdventOfCode Dec 12's puzzle in @fuzionlang.bsky.social: First thought this is impossible and put it aside, but the input data is so simple that there is no need to check actual present arrangements as long as the total size fits. The sources on github: github.com/fridis/fuzio...
![dec12 =>
input := io.stdin.read_string.trim.split "\n\n" .as_array
grids := input[6].split "\n" .map (.split ": ")
areas := grids.map (g->g[0].split "x" .map (.parse_i32.val))
pcnts := grids.map (g->g[1].split " " .map (.parse_i32.val))
part1 =>
# just stupidly count if the number of #s would fit, ignoreing the
# actual shapes. Does not work in general, but for the given input:
# present reduced to number of #s
presents := array 6 (i->input[i].codepoints.count ="#")
a2 := areas.map (.product) # areas reduced to size
p2 := pcnts.map (.zip presents (*) .sum) # total count of #s
# sum up presents * counts and check if fits into areas
a2.zip p2 (>=)
.count id
part2 =>
"Merry Christmas"
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreibn5c4s43vhcxrsg5yhd2wmsnlmxvmedf2hze3edfamtoz3grzfai)
The Fuzion December news are out. Next to many incremental improvements on the Fuzion language, libraries and tools, work has started on a new tool for runtime scheduler monitoring called feeze. All the details: fuzion-lang.dev/news/news_057
fuzion-lang.dev
#AdventOfCode Dec 11's puzzle in @fuzionlang.bsky.social: I first did not expect simple counting of paths to be sufficient, but with memoization, that worked fine. The sources on github: github.com/fridis/fuzio...
![dec11 =>
input := io.stdin.read_string.trim.split "\n" .map (.split ": " .as_tuple)
nums := container.hash_map (input.map (.0)) 0..input.count-1
num(name) => nums[name].or_else -1
succs := input.map (.1.split " " .map dec11.this.num) .as_array
dac := num "dac"
fft := num "fft"
cnts(n,d,f,b u64) is # counts (n)one, (d)ac, (f)ft, (b)oth
count(n i32) cnts : memoize => keep n _->
if n < 0 then cnts 1 0 0 0
else
r := succs[n].map count
.fold1 a,b->(cnts a.n+b.n a.d+b.d a.f+b.f a.b+b.b)
if n=dac then cnts 0 r.n+r.d 0 r.d+r.f+r.b
else if n=fft then cnts 0 0 r.n+r.f r.d+r.f+r.b
else r
part1 => count (num "you") .n
part2 => count (num "svr") .b
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreie3jmjkjgeoodwjtgraigt3zwimimexliqa5j4pkacfclenz26t54)
Five days late with my #AdventOfCode solution in @fuzionlang.bsky.social. After part 1 was super easy, I struggled with the shear amount of work for solving the underspecified system of linear algebra equations in part 2. But then I found www.reddit.com/r/adventofco..., a very nice idea... 1/2
![dec10 =>
input := io.stdin.read_string.trim.split "\n"
.map (.split " ") .map data .as_array
data(s) is
lights := s[0].replace "[" ""
.replace "]" ""
.codepoints.foldf (0,1) e,c->(e.0|(c="#"?e.1:0),2*e.1)
.0
buttons := (s.drop 1 .take s.count-2).map (.replace "(" ""
.replace ")" ""
.split ","
.map c->1<<c.parse_i32.val
.fold1 (|))
.as_array
joltage := s.last.val.replace "\{" ""
.replace "\}" ""
.split ","
.map (.parse_i32.val)
try(l,n) =>
l=lights || n!=0 && (buttons ∃ b->try l^b n-1)
p2 =>
# solution proposed by u/tenthmascot at
# https://www.reddit.com/r/adventofcode/comments/1pk87hl/2025_day_10_part_2_bifurcate_your_way_to_victory/
solve(j) : memoize => keep "$s/$j" _->
if j ∀ =0 then 0 # all 0, nothing more to do
else
l := j.indexed.map ||>i,jo->jo%2<<i .fold1 (|) # desired lights = odd joltages
(0..(2**buttons.length-1)).map m-> # for all button combinations
pr := buttons.zip (m :: (/2)) b,mb->mb%2*b # pressed buttons
if l = pr.fold1 (^) then # resulting lights ok?
j2 := j.indexed.map ||>i,jo->(jo - (pr.map b->(b>>i)%2 .sum))/2
m.ones_count + 2 * solve j2 # recurse with halved joltage
else 1000000
.min.val
solve joltage
part1 =>
input.map d->((0..).drop_while n->(!d.try 0 n))[0]
.sum
part2 =>
input.map (.p2)
.sum
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreifhkjxly6lrwyvl3be4nwrt2enletz3vq6yrfib5yiwcmsq5mrn2q)
Today's @adventofcode.bsky.social in @fuzionlang.bsky.social started with a simple part 1: two lines after input preprocessing and defining a helper feature to calculate the area of a rectangle. Part 2 is more tricky, requires checking if a rectangle is contained in a concave polygon. 1/2
![dec9 =>
input := io.stdin.read_string.trim.split "\n"
.map (.split "," .map (.parse_i64.val) .as_tuple) .as_array
# area or rectangle with corners a and b
rect(a,b) => ((|a.0-b.0|)+1)*((|a.1-b.1|)+1)
part1 =>
input.combine input rect
.max
part2 =>
xs := input.map (.0) .unique .sort # all used x coordinates
ys := input.map (.1) .unique .sort # all used y coordinates
x(v) => xs.find_key v .val.as_i64 # compress x to index in xs
y(v) => ys.find_key v .val.as_i64 # compress y to index in ys
m : mutate is
m ! ()->
floor := m.env.new_array2 xs.length.as_i64 ys.length.as_i64 "."
# put outline tiles
(input ++ [input[0]])
.map_pairs p,q->
px := x p.0; py := y p.1
qx := x q.0; qy := y q.1
_ := for xi := px, xi+(qx-px).sign.as_i64
yi := py, yi+(qy-py).sign.as_i64
while xi!=qx || yi!=qy do
if floor[xi,yi]="." then floor[xi,yi] := "X"
.for_each ignore # enforce side-effect
# clear outside area
floor.indices1.for_each y->
clear(x) => if floor[x,y]="." then floor[x,y] := " "; true
else false
_ := floor.indices0 .take_while clear .count
_ := floor.indices0.reverse.take_while clear .count
# try all rectangles
input.combine input a,b->
xr := [x a.0, x b.0].sort.as_tuple ||> (..) # range of x coord.
yr := [y a.1, y b.1].sort.as_tuple ||> (..) # range of y coord.
if xr.combine yr floor[] ∀ !=" " then rect a b
else 0
.max
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreiedt34unblkddrtt7prnx4trbnwcjkjavgnxggecjtyxfaytxoyoa)
@adventofcode.bsky.social getting more challenging: Today's solution in @fuzionlang.bsky.social declares an orderable feature `pair`, cuircuits are equivalence classes identified by the first box. And reading comprehension: www.reddit.com/r/adventofco... The sources: github.com/fridis/fuzio...
![dec8 =>
input := io.stdin.read_string.trim.split "\n"
.map (.split "," .map (.parse_i64.val) .as_array) .as_array
n := input.length
m := envir.args[1].parse_i32.val
pairs := (0..n-1).flat_map (i -> (i+1..n-1).map (pair i))
.sort
# get circuit id of junction box i
#
# cs[i] is >0 if i is identifying box, value is size of circuit,
# <0 if identifiying box is at i+cs[i]
circuit(cs, i) =>
if cs[i]<0 then circuit cs i+cs[i]
else i
# pair of junction box i and j, ordered by straight-line distance
pair(i,j) : property.orderable is
# straight-line distance between i and j
dist := input[i].zip input[j] (-) .map **2 .sum
# order
public redef type.lteq(a,b pair.this) bool => a.dist <= b.dist
# connect this pair for given circuit cs, return resulting circuit
connect(cs) =>
ab := (circuit cs i, circuit cs j)
a := ab ||> min
b := ab ||> max
if a=b then cs
else array n x->
if x=a then cs[a] + cs[b]
else if circuit cs x = b then a-x
else cs[x]
part1 =>
join(c,cs) i32 =>
if c = m then cs.sort.reverse.take 3 .product
else join c+1 (pairs[c].connect cs)
join 0 (array n _->1)
part2 =>
join(c,cs) =>
p := pairs[c]
cs0 := p.connect cs
if cs0[0]=n then input[p.i][0]*input[p.j][0]
else join c+1 cs0
join 0 (array n _->1)
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreife3iacuwgiyie6c2badn72hgyrqikwwnxcmxtywkzzvrmfc7pdze)
Yesterday's @adventofcode.bsky.social solution in @fuzionlang.bsky.social: arrays used instead of lists to avoid quadratic performance. part2 was simpler than part1... The sources on github: github.com/fridis/fuzio...
![dec7 =>
input := io.stdin.read_string.trim.split "\n"
.map (.codepoints.as_array) .as_array
w := input[0].count
part1 =>
input.foldf (0,array w _->false) e,l->e||>c,a->
a2 := array w x->
(l[x]="S" ||
l[x]="." && a[x] ||
x>0 && l[x-1]="^" && a[x-1] ||
x<w-1 && l[x+1]="^" && a[x+1])
c2 := c + a.indices.count (x -> l[x]="^" && a[x])
(c2,a2)
.0
part2 =>
input.foldf (array w _->(i64 0)) a,l->
array w x->
(if l[x]="." then a[x]
else if l[x]="S" then 1
else 0
+ if x>0 && l[x-1]="^" then a[x-1] else 0
+ if x+1<w && l[x+1]="^" then a[x+1] else 0)
.sum
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreih5ogpbdhvvw66rkg2pkj4g6sqx7likwt5yjgsumb644weivo5gzm)
St. Nicolas' @adventofcode.bsky.social in @fuzionlang.bsky.social required tricky transposing in part 2. Surprise for me: partial application of operators usually requires '('/')', not here: 'fold1 (if op="*" then * else +)' or even 'fold1 (op="*" ? + : *)'. sources: github.com/fridis/fuzio...
![dec6 =>
input := io.stdin.read_string.trim.split "\n" .as_array
h := input.length-1
part1 =>
a := input.map (.split " " .filter !="" .as_array) .as_array
a[0].indices.map x->
op := a[h][x]
(0..h-1).map y->a[y][x].parse_i64.val
.fold1 (if op="*" then * else +)
.sum
part2 =>
w := input.map (.trim.byte_length) .max.val
i := input.map_to_array (.codepoints.as_array)
next(c) =>
if c<w && (0..h ∃ y->i[y][c]!=" ") then next c+1
else c+1
(0 :: next).take_while <=w
.map c->
op := i[h][c]
(c..(next c)-2).map x->
(0..h-1).foldf "" e,y->e+i[y][x]
.trim.parse_i64.val
.fold1 (op="*" ? * : +)
.sum
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreibtb5dto7ko6lclxqenglk4dewtzyrfs7n5mrf3e7pvvisj7zrigy)
Today's @adventofcode.bsky.social solution in @fuzionlang.bsky.social: Instead of testing all the ways two ranges can overlap, just checking if they are completely separate and joining them if not helped a lot. And there is an existential operator ∃! The source: github.com/fridis/fuzio...
![dec5 =>
fr,id := io.stdin.read_string.trim.split "\n\n" .as_tuples.first.val
fresh := fr.split "\n" .map (.split "-" .map (.parse_i64.val) .as_tuple)
ids := id.split "\n" .map (.parse_i64.val)
none := fresh.take 0
part1 =>
ids.count i->
fresh ∃ ||> a,b -> a<=i<=b
separate(a,b) => a.1+1 < b.0 || b.1+1 < a.0
join(a,b) => (min a.0 b.0, max a.1 b.1)
part2 =>
fresh.foldf none l,n-> # create list of disjoint ranges, adding one range n at a time
h, t := l.foldf (n, none) r,f-> # for each range f we found so far
if separate r.0 f then (r.0, [f] ++ r.1) # r.0 and f separate, so keep both
else (join r.0 f, r.1) # else join r.0 and f
[h] ++ t
.map (||> a,b -> b-a+1)
.sum
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreib4o36sff3dtma26z6ndlf77vhjxrsv36ebla4t7wj6rca5gceqle)
Finally an @adventofcode.bsky.social solution in @fuzionlang.bsky.social on the same day: Using an array2 2 slots wider and higher helps avoid many special cases. A bit cryptic, but convenient: ||>x,y->... defines a lambda on a tuple and destructures the tuple. Source: github.com/fridis/fuzio...
![dec4 =>
input := io.stdin.read_string.trim.split "\n"
.map (l -> l.codepoints.map ="@" .as_array)
.as_array
w := input[0].length
h := input.length
a := array2 w+2 h+2 x,y->
1 <= y <= h && 1 <= x <= w && input[y-1][x-1]
# array2 of bool with directly inaccessible rolls in array2 `o`
inaccessible1(o) =>
array2 w+2 h+2 x,y->
if o[x,y] then ((x-1 .. x+1).pairs (y-1 .. y+1)
.count ||>xx,yy->o[xx,yy])>4
else false
# count of recursively inaccessible rolls
inaccessible(o) =>
i := inaccessible1 o
co := o.count id
ci := i.count id
co = ci ? ci : inaccessible i
part1 =>
i := inaccessible1 a
a.index_pairs.count ||>x,y->
a[x,y] && !i[x,y]
part2 =>
a.count id - inaccessible a
say "$part1:$part2"](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:u7wbrkp6uajkelqrlmcc2dde/bafkreiaecq5tubtc2hvuszgx5trr7xs7wq5pzysflopm7tjfqvra4l566u)
Catching up with this year's @adventofcode.bsky.social, here is a fairly concise solution for yesterday's challenge using @fuzionlang.bsky.social: A recursive function joltage(n,v,l) did the trick for length n, current result v and remaining list l. The sources: github.com/fridis/fuzio...
Still lagging behind with Dec 2's @adventofcode.bsky.social in @fuzionlang.bsky.social: very useful was Sequence's unique feature to remove repeated ids. Source: github.com/fridis/fuzio...
A little late to the show for Dec 1's @adventofcode.bsky.social in @fuzionlang.bsky.social: Went for a simple, fully functional solution using 2 nested folds that perform single clicks of the dial, optimizing this resulted in uglier code with too many cases. Source: github.com/fridis/fuzio...
The Fuzion November news are out. Our base library profits a lot from the work on the fuzion webserver fzweb: added functionilty, better usability and performance! For the Fuzion language, type-safe variadic functions are an major addition. All the details: fuzion-lang.dev/news/news_056
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
The Fuzion October news are out. We are making fast progress implementing the webserver behind fuzion-lang.dev to Fuzion. On the Fuzion language, handling of lambdas and variadic type parameters and value argument is becoming more powerful. All the details: fuzion-lang.dev/news/news_055
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
The Fuzion September news: An efficient and type-safe mechanism for variable argument lists for functions is one of the exciting things we are working on. All the details: fuzion-lang.dev/news/news_054
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
The Fuzion August news: Major news for the Fuzion language are support for loop correctness checking via loop invariants and faster static analysis. Here are the details: fuzion-lang.dev/news/news_053
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
The Fuzion July news: Last month brought some nice language improvements for destructuring, nullary functions and automatic unwrapping together with a number of enhancements in the base library, bug fixes and code cleanup in the tools. Here are the details: fuzion-lang.dev/news/news_052
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
The Fuzion June news are out: Progress on the foreign function interface is now demonstrated with an example calling the GTK toolkit. Support for right associative operators make infix operation like piping to the left <| more natural. Here are the details: fuzion-lang.dev/news/news_051
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
The Fuzion May news are out: Last month saw a large number of minor fixes in the Fuzion language, compiler and base library combined with some larger progress towards native library interfacing via value types and callbacks. Here are the details: fuzion-lang.dev/news/news_050
Fuzion Language Portal
Fuzion is a computer programming language with a focus on productivity, performance and correctness.
fuzion-lang.dev
The Fuzion April news are out. The focus shifted towards a Fuzion language improvements, generally turning experience we gain using Fuzion into language improvements. Meanwhile, important progress is happening on the native interface. Here are the details: fuzion-lang.dev/news/news_049
Fuzion Language Portal
Fuzion is a computer programming languange with a focus on productivity, performance and correctness.
fuzion-lang.dev