Well, Mufi-Lang was lacking editor support, and well I started tinkering with my own knowledge app (Notion, Obsidian, etc.) in Swift which would take advantage of Metal acceleration, and thought wait a minute, I have Mufi-Lang 😂

So seeing how useful AI can be, I had it try to make some editor for me, and with many frustrating trial and errors, and shouting at the chat, we got Ferrufi!!!

To install you can run the following command:

$ curl -fsSL https://raw.githubusercontent.com/Mufi-Lang/Ferrufi/main/scripts/installer.sh | bash

So what features do we have right now???

Native Editor Support

Huh? Well I did something cool, or I thought of it, so we got MufiZ, so why don’t we separate the compiler into two, a library and an executable. Where the library can then be compiled into a dynamic library and linked with Swift using C-ABI.

So now we have Ferrufi natively be able to run mufi code, and also run the REPL mode, it is so cool!!!

Syntax Highlighting Support

We currently are using a Regex based highlighting support for Mufi-Lang, but I’m hoping that this will evolve over time, with possibly using some sort of formal spec highlighting or maybe come up with our own unique approach.

Theme Manager

We got a nice theme manager that you can click and preview nicely of each theme so you can choose the most perfect one for your editing style.

Notes

This is our first release, so do expect bugs, and some things have not been implemented yet like our activity bar, so there will be upcoming releases to fix these various issues. I also hope to put more into how MufiZ interacts with the editor like better workspace support, and hoping to explore replacing the job of an LSP with a neural network model, so there’s a lot of exciting things in place for 2026 and Mufi-Lang!!!

New Features

• Foreach loop support foreach(v in vector)

• Added complex number parsing var c = 2 + 3i

• Added multiline string (`hello`;) and comment (/# #/) support.

• Added end keyword for indexing arrays last element (like Matlab)

• Added const support for immutable variables

• Added format() and f() functions for formatting strings like format("Hello, {}!", "World") and f("Hello, {}!", "World").

• Added hashtable syntax using #{key: value} such as var table = #{"key": 4}; and indexing using table["key"].

• Added switch statement support switch(expression) { case value: {expression; break;}, ... }

• Added experimental range support (..= and ..)

• Added pair type key => value

• Added Matrix type support ([[1, 2, 3], [4, 5, 6]]) and added indexing support using mat[row][col] syntax.

  • For iterating on foreach, you will need to run foreach(a in flatten(mat))

Other Changes

• Upgraded Zig toolchain to v0.15.2

• Changed Float Vector to be dynamic

• Improved Hash Table to use Standard Library

• Reworked memory management to use Zig’s Allocator type and prioritize safety checks and memory leak detection. We choose to use Zig’s General Purpose Allocator and for lifetime objects we use arena allocation.

• Reworked REPL editor that allows for multi-line statements

• Better error messaging in the language and token column reporting is implemented

• Dynamic String hashing depending on length of string to provide optimal performance.

# To install on Unix Systems!
$ curl -fsSL https://raw.githubusercontent.com/Mufi-Lang/installer/main/installer.sh | sudo sh -s install
# To use after, run the mufizup command 
$ mufizup update # updates to latest version

With this release, I will no longer be continuing to use apt/dnf repo, and instead for Unix systems I will be improving the mufizup shell script that can be used to install mufiz for different toolchains and handle updating, and selecting versions. For MacOS and x86-64 Linux systems brew will also continued to be supported and we also have our Github release https://github.com/Mufi-Lang/MufiZ/releases/tag/v0.10.0

Const Support

In this release we provide support to immutable variables in both global and local scopes through the const keyword, you can assign a variable to immutable instead of the mutable var keyword.

Pairs Support

We introduce a new object called Pairs which act as a key-value pair which can either be directly created using the syntax key => value or can be collected from a Hash-Table using the pairs() function which can be iterated upon, further work will be looked at for further integration with the hash-table type.

Switch Support

We are adding support for switch statements which are similar to a mix between C but instead of : we use => as shown below:

var a = 3;
print("Switch value: " + a);

switch(a){
    case 1 => { print("Entered case 1"); assert(a, 1); break;},
    case 2 => { print("Entered case 2"); assert(a, 2); break;},
    case 3 => { print("Entered case 3"); assert(a, 3); break;}
}
print("End of switch");

Range Support

We are adding exclusive (start..end) and inclusive (start..=end) ranges support, further work is being done to ensure they work nicely with foreach loops and switch statements, and may not be fully stabilised until v0.11.0.

Switch to Zig v0.15.0 Toolchain

The new Zig release has come out and a lot of refactoring is being done to replace old code with the new Io type and it involves the networking functions to be rewritten as well. This is an exciting release, and we are happy to quickly adopt it to our language.

var a = {1, 2, 3};
foreach(x in a){
    print a;
}
// 1
// 2
// 3

The foreach loop was something I wanted to bring in Kova but didn’t get the chance to, and between me switching back and forth between foreach(x in foo) and each(x : foo), I decided to go with well what I already showed, and I’m happy its now in the language!

Next is more helpful error messages! Our error messaging system was all over the place, and now I have gotten it under control, and better under an Error Manager to handle detecting the type of error, and providing suggestions that may help, these suggestions are quite generic but better than nothing ;)

Error Categories

The error system categorizes errors into the following types:

Syntax Errors

• UNEXPECTED_TOKEN: Wrong token found where another was expected

• UNTERMINATED_STRING: String literal missing closing quote

• INVALID_CHARACTER: Invalid or unexpected character in source code

• MISSING_SEMICOLON: Missing semicolon where required

• MISMATCHED_BRACKETS: Mismatched [], {}, or () brackets

Semantic Errors

• UNDEFINED_VARIABLE: Reference to undeclared variable

• REDEFINED_VARIABLE: Variable declared multiple times in same scope

• UNDEFINED_FUNCTION: Call to undefined function

• UNDEFINED_PROPERTY: Access to undefined object property

• WRONG_ARGUMENT_COUNT: Function called with wrong number of arguments

Type Errors

• TYPE_MISMATCH: Operation between incompatible types

• INVALID_CAST: Invalid type conversion

• INCOMPATIBLE_TYPES: Types cannot be used together

Runtime Errors

• STACK_OVERFLOW: Too many nested function calls

• INDEX_OUT_OF_BOUNDS: Array/vector access outside valid range

• NULL_REFERENCE: Access to null object

• DIVISION_BY_ZERO: Division or modulo by zero

Memory/Limit Errors

• TOO_MANY_CONSTANTS: More than 256 constants in one function

• TOO_MANY_LOCALS: More than 256 local variables in function

• TOO_MANY_ARGUMENTS: More than 255 function arguments

• LOOP_TOO_LARGE: Loop body exceeds maximum size (65535 bytes)

• JUMP_TOO_LARGE: Conditional jump distance too large

Class/Object Errors

• INVALID_SUPER_USAGE: 'super' used outside class or without inheritance

• INVALID_SELF_USAGE: 'self' used outside class context

• CLASS_INHERITANCE_ERROR: Invalid class inheritance (e.g., self-inheritance)

• METHOD_NOT_FOUND: Called method doesn't exist on object

Error Message Format

Each error message includes:

1. Severity Level: Error, Warning, Info, or Hint

2. Location: File, line, and column number

3. Category: The type of error (Syntax, Runtime, etc.)

4. Message: Clear description of what went wrong

5. Context: Relevant source code with error highlighting

6. Suggestions: Helpful advice on how to fix the error

7. Examples: Code examples showing correct usage (when applicable)

Example Error Output

Error [script:15:23] (Syntax) Unexpected token 'var', expected ')'
    var result = add(5, var x = 10);
                       ^^^
  Suggestion: Replace 'var' with a valid expression
    Fix: Remove variable declaration from function call
    Example: var result = add(5, x);

  Suggestion: Declare variables outside function calls
    Example: var x = 10; var result = add(5, x);

Common Error Scenarios and Suggestions

Undefined Variables

Error: Undefined variable 'userName'

Suggestions:

• Declare the variable before using it

• Check spelling (did you mean 'username'?)

• Ensure variable is in correct scope

Fix Examples:

// Before (error)
print(userName);

// After (fixed)
var userName = "John";
print(userName);

Wrong Argument Count

Error: Function 'add' expects 2 arguments, but 1 were provided

Suggestions:

• Add the missing argument

• Check function signature

• Verify you're calling the correct function

Fix Examples:

// Before (error)
var result = add(5);

// After (fixed)
var result = add(5, 3);

Stack Overflow

Error: Stack overflow - too many function calls

Suggestions:

• Check for infinite recursion

• Add base case to recursive functions

• Consider using iteration instead

• Limit recursion depth

Fix Examples:

// Before (infinite recursion)
fun factorial(n) {
    return n * factorial(n - 1);
}

// After (with base case)
fun factorial(n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

Index Out of Bounds

Error: Index 5 is out of bounds for size 3

Suggestions:

• Valid indices are 0 to 2

• Check array/vector size before accessing

• Use bounds checking

Fix Examples:

// Before (unsafe)
var value = arr[index];

// After (safe)
if (index >= 0 && index < arr.length) {
    var value = arr[index];
} else {
    print("Index out of bounds");
}

Invalid Super Usage

Error: Cannot use 'super' outside of a class

Suggestions:

• Use 'super' only inside class methods

• Ensure class has a parent class

• Move super call into class definition

Fix Examples:

// Before (error)
super.method();

// After (fixed)
class Child extends Parent {
    method() {
        super.method();
    }
}

Did You Mean Suggestions

The error system includes intelligent "did you mean" suggestions for:

• Variable names: Suggests similar variable names based on edit distance

• Function names: Suggests similar function names when available

• Method names: Suggests available methods on objects

• Keywords: Suggests correct keywords for typos

Example

Error: Undefined variable 'usrName'
  Suggestion: Did you mean 'userName'?

Error Recovery

The compiler includes panic mode recovery:

1. Enter Panic Mode: When an error is detected

2. Skip Tokens: Continue parsing by skipping problematic tokens

3. Synchronization Points: Recover at statement boundaries

4. Exit Panic Mode: Resume normal parsing

This allows the compiler to report multiple errors in a single compilation pass

The first big thing in this release is the fact that all types in the language are now Zig types! They no longer are C-ABI types, this was a big thing to be able to accomplish and this helps with stability, memory safety and overall ease of development in the language from now on.

We have also added indexing support! This is something I wanted for a while, and now it comes, my next hope in the next release is to introduce a foreach loop, but that has its difficulty to implement.

Anyways indexing is the same as you expect in other languages, we use [idx] and index starts at 0. This is available to be used for Float Vectors only.

var f = {1, 2, 3, 4};
print f[0]; // 1

Along with this, we have made many improvements and fixes to the language, like better keyword looking up, a new Garbage Collector using Generational technique and reference counting. We also have a new allocator interface that replaces the use of malloc/realloc/free, and overall the language is a lot more stable.

Learn more at the Release!

Wait…what? The goal of this is to cleanup our codebase, and fix functionality into the language, and increase our test suite to be able to catch more and more bugs in our language.

For example did you know MufiZ v0.8.0 can’t even run this program:

class Zoo {
  init() {
    self.aardvark = 1;
    self.baboon   = 1;
    self.cat      = 1;
    self.donkey   = 1;
    self.elephant = 1;
    self.fox      = 1;
  }
  ant()    { return self.aardvark; }
  banana() { return self.baboon; }
  tuna()   { return self.cat; }
  hay()    { return self.donkey; }
  grass()  { return self.elephant; }
  mouse()  { return self.fox; }
}

var zoo = Zoo();
var sum = 0;
var start = now();
while (sum < 100000000) {
  sum = sum + zoo.ant()
            + zoo.banana()
            + zoo.tuna()
            + zoo.hay()
            + zoo.grass()
            + zoo.mouse();
}

print now() - start;
print sum;

Because we had an issue on how self was being initialized in the Virtual Machine, it would just crash.

In this release, we are not only cleaning up the language and fixing it, we also are removing a lot of our C dependence. What does that mean in practice, it means that currently I have been able to keep the language using realloc, and free but it no longer points to malloc in the C standard library, but instead is a wrapper to use Zig’s General Purpose Allocator.

I also hope to be able to remove the use of C pointers in the language, and be able to just use Zig’s native types. This release may not include new features, but it will ease development and hopefully reduce the amount of cruff in the language.

Changing the Memory model to use GlobalAlloc

To further remove our C dependency, we need to move away from using malloc and instead put everything under our GlobalAlloc which uses Zig’s General Purpose Allocator. This will help us determine any memory leaks and double frees that exist in the language and also will be a good step towards converting types from being [*c]T to a Zig pointer, depending on how it may be needed to be used, it could be a slice []T, an optional multi-item pointer ?[*]T.

Make FVec Dynamic the default Array Implementation.

Once we have FVec using []f64, we can start making it dynamic and better using SIMD for binary operations a lot easier. This should help improve the ergonomics of the structure. Once we clean up many of the C pointer types and extern structures, we can start moving all structure functions as boundary methods, making the language work a lot easier.

Move CStd to Stdlib

Let’s move all of the Cstd stuff, which revolves around objects mainly, to stdlib, and this will give us an opportunity to organize it further.

This doesn’t sound too much, but will probably take a couple of months to handle since I am the only one who works on this, but hopefully doing this will make it easier and less overwhelming on myself.

Step 1: Translate and Link

The beginning of the transformation was translating all the C files into Zig files using Zig’s translate-c command. This tool is so powerful and amazing, so from there, we started adding it to the build.zig file linked to the Zig file and removed the C linking.

Step 2: REMOVE A LOT OF F- BINDINGS

Once we confirm linking is working fine, we start to remove the excessive bindings and have only the core stuff in the file, and begin importing. I wish Zig had like a import * command, I really do, because it would’ve saved me so much time.

During this stage, which was the longest, I had to deal with hundreds of errors, and thanks to my editor, Zed, and multiline buffering, I was able to handle the errors much more easily.

Also, during this stage, I realized how many integer overflow cases were just not handled in C because, well, it was never reported to me. So, those I had to handle in Zig made me happier about this porting experience.

Step 3: Cleanup…well try to

Yeah, I tried to clean up as much as I could, but there’s still stuff that I will have to do. During this stage, I found our array type acting very strangely, and we didn’t need the design; it was better to have FloatVector. Matrix is broken so got rid of that and once the research is in, we will put it back in, also once we switch our memory model to use Zig’s allocator, we can breathe easier.

Conclusion

There is still a lot to improve in our code base, honestly being a solo developer maintaining 10000 lines of code is overwhelming, but that’s why over releases I will be continuously fixing the code, some releases will have new features, others will just be small fixes.

But the main work has been completed, and having it all under a single language makes my life much easier and less sparse. We can finally better organize the language and make it more DRY. Compiling will be faster due to avoiding linking, and we can take advantage of more of the Zig features and start to support more toolchains once we remove that C dependency.

Well it compiles...butttt without a standard library, runtime error reporting is off, and there is possibly an integer overflow issue with the VM garbage collector, so how do we handle this?

Well first thing to make everything better is moving away from C ABI, which is very hard, because everything is currently in C ABI, but we must to have things work! And so we can move away from malloc and to Zig's general purpose allocator which has better safety features.

I don't expect myself to complete this task in a couple of weeks, it'll probably be a few months, where was is happy news, the next is just cussing, and the other I post another update :)

To look at how it operates, consider the following visuals:

   +-------------------+
   |       START       |
   +-------------------+
            |
            v
   +-------------------+
   |      GC_IDLE      |<-----------------+
   +-------------------+                  |
            |                             |
            v                             |
   +-------------------+                  |
   |   GC_MARK_ROOTS   |                  |
   |                   |                  |
   | +---------------+ |                  |
   | |  Mark Stack   | |                  |
   | +---------------+ |                  |
   |         |         |                  |
   |         v         |                  |
   | +---------------+ |                  |
   | | Mark Frames   | |                  |
   | | Mark Globals  | |                  |
   | | Mark Strings  | |                  |
   | | Mark Upvalues | |                  |
   | +---------------+ |                  |
   +-------------------+                  |
            |                             |
            v                             |
   +-------------------+                  |
   |    GC_TRACING     |                  |
   |                   |                  |
   | +---------------+ |                  |
   | |  Gray Stack   | |                  |
   | |   +-+  +-+    | |                  |
   | |   |o|  |o|    | |                  |
   | |   +-+  +-+    | |                  |
   | +---------------+ |                  |
   |         |         |                  |
   |         v         |                  |
   | +---------------+ |                  |
   | | Blacken Objs  | |                  |
   | +---------------+ |                  |
   +-------------------+                  |
            |                             |
            v                             |
   +-------------------+                  |
   |    GC_SWEEPING    |                  |
   |                   |                  |
   | +---------------+ |                  |
   | | Object List   | |                  |
   | | [o]->[o]->[o] | |                  |
   | +---------------+ |                  |
   |         |         |                  |
   |         v         |                  |
   | +---------------+ |                  |
   | |  Free/Unmark  | |                  |
   | +---------------+ |                  |
   +-------------------+                  |
            |                             |
            v                             |
   +-------------------+                  |
   |    Update GC      |                  |
   |    Threshold      |------------------+
   +-------------------+
            |
            v
   +-------------------+
   |       END         |
   +-------------------+

As you can see, we can pause and resume at any state to allow program execution, which should allow for more performance and better latency. Our goal is to find an actual number of these to see how else we can further optimize our structures within our language.

With this new release, we will soon update all package managers to express this change and update our website and VSCode extension with the latest built-ins.

Release Notes for Jade (0.7.0)

• Started on April 24th 2024.

• Released on July 6th 2024.

New Features

• New Array and Float Vector semantics using [ ] and { } respectively.

  • Done in commits 4f7831d and a586b3e.

• Iterators for Array and Float Vectors.

  • Done in commits 416e915, 2311323 and fa0b305

Other Changes

• Fixed Vec3 builtin functions that were broken in v0.6.07fbc1b6

• Changed default hashing algorithm to cityhash64: 8734e1b

• Added helpful boolean macros for object type checking in builtin functions (cstd): 55585a50

• Updated MufiZ's interpret error to be treated as a Zig error when running a file: 4f7f9fd

• Adjusted Table implementation to use lazy deletion instead of tombstoning: bddabfa

• Updated Zig version to v0.13.0: 788fbf2

• Updated to clap v0.9.1

• Added Arm SIMD support using Neon intrinsics fa0b305

• Added Test Suites that brought plenty of fixes to builtins

• Switched stdlib_error to make use of runtimeError so that it can also provide line numbers to the user.

Added Builtin Functions

• assert: Checks if the given condition is true; if not, it panics.

• simd_stat: Checks if SIMD is supported on the current platform.

• iter: Creates an iterator from an array or a float vector.

• next: Advances the iterator and returns the next element.

• has_next: Checks if the iterator has more elements.

• reset: Resets the iterator to the beginning.

• skip: Skips the next n elements.

View Github Release

While I do expect that there will be some unexpected behavior lurking out there that needs to be adjusted, which is why we are creating a test suite for this release, this has been the easiest migration so far.

This release also includes toolchain upgrades in the Zig compiler, such as going to LLVM 18, glibc 2.39, and musl 1.2.5. I am happy we can easily take advantage of this new compiler so soon. This is another reason to be excited about the upcoming Jade Release, which still needs a few months of baking.

RPM:

• Fedora 38/39/40

• OpenSuse 42.3

Deb:

• Ubuntu Jammy/Noble

• Debian Bookworm/Trixie/Forky

Installation Instructions

For those wanting to install mufiz version v0.6.0, you can follow these instructions:

# For Ubuntu
$ curl -s https://packagecloud.io/install/repositories/Mustafif/MufiZ/script.deb.sh | sudo bash
$ sudo apt-get install mufiz=0.6.0

For Debian Packages, we support the following architectures on here:

• amd64

• i386

• arm64

• mipsel

• mips64el

• mips

• powerpc

# For Fedora
$ curl -s https://packagecloud.io/install/repositories/Mustafif/MufiZ/script.rpm.sh | sudo bash
$ sudo yum install mufiz-0.6.0-1.{arch}

For Fedora {arch} can be replaced with your respective supported architecture:

• x86_64

• i386

• aarch64

• ppc64

• ppc64le

• mipsel

• mips64el

• mips64

• mips

• riscv64

Archival Plan

Because I'd rather not pay for package_cloud, I will only be keeping the top 4 versions (beginning with v0.6.0) at a time on the platform, of course, all packages are available on Github releases; this helps me keep space for the next versions since each release contains 75 ARCHIVES TO KEEP!!!

For those wanting to see the little client I made to help me download and upload the deb/rpm packages can be found at https://github.com/Mustafif/mufiz_pkg, where the client is built in Dart, because I've started learning it.

Our first initiative is creating a great Matrix implementation and algorithms following numeric stability and linear algebra. This work is being done in the MatrixAlgo repository with a collaborative effort between myself and my friend GriffinAshby01.

The second initiative will help the MufiZ project and can be used by anyone; once developed, this project will be named. Zigma, and its goal is to host many different numerical methods for approximating integrals, derivatives, etc.

To support us, consider contributing directly to these projects or sponsoring.

New Repos:

• https://github.com/Mustafif/MufiZ-APT

  • This repo contains all of our .deb files for the apt package manager for Debian-based Linux distros.

• https://github.com/Mustafif/mufi-bucket

  • This is our own maintained bucket that contains MufiZ Windows systems, and supports installation for x86_64, x86 and arm64.

  • This is for the scoop package manager, and I found this manager to be a lot better than the official winget tool.

• https://github.com/Mustafif/homebrew-mufi

  • This is our maintained tap for the brew package manager and supports installing both arm and intel Macs, as well as
    Linux.

I hope these efforts help make everyone's lives easier. It was a fun experience learning how to make custom repositories for these managers. Any other multi-platform project I work on will be hosted on these.

Release Notes for Mars (0.6.0)

• Started on February 21st 2024.

• Released on April 23rd 2024.

New Features

• Added support for Matrix data type.

• Added support for FVector data type.

  • This data type is a fixed array of floating point numbers that is able to use SIMD instructions.

  • This data type is used to represent vectors in 3D space.

• Added network support via being able to send CRUD requests.

  • This is able to be done using native Zig networking.

• Added exponent token ^

• Proper random number generation with either uniform or normal distribution.

Other Changes

• Lots of code cleanup and added more documentation.

• More functionality in the language with added builtin functions.

• Updated to v0.8.0 of clap for the CLI.

• Added features to optionally disable networking and filesystem access, and to enable sandboxing (REPL only).

• Optimize your code with the new FVector data type, which can perform operations 3x faster than the Array data type.

• Updated what_is function to be able to identify any Object type.

• Updated build_multi to use the Zig build system instead of a Python script which would have caching conflicts. Using a seperate Python script for packaging the binaries.

• Adding support for package managers like apt and scoop to install MufiZ.

• Switched from using FNV-1a to xxhash64 for hashing.

  • Will do a benchmark in the future to test the performance between fnv1a, cityhash64 and xxhash64.

• Switched to building targets: arm-linux on Debug optimization due to an LLD issue.

• Added x86 target support.

Added Builtin Functions

Math

• rand(): Generate a random number between 0 and 1.

• randn(): Generate a random number with a normal distribution.

Networking

• get_req(): Send a GET request to a server.

• post_req(): Send a POST request to a server.

• put_req(): Send a PUT request to a server.

• del_req(): Send a DELETE request to a server.

Collections

• matrix(): Create a matrix with the given dimensions.

• fvec(): Create a vector with the given size or array.

• linspace(): Create a float vector of evenly spaced numbers.

• slice(): Get a subarray of an array.

• splice(): Remove a subarray from an array.

• sum(): Get the sum of a list.

• mean() Get the mean of a list.

• std() Get the standard deviation of a list.

• var() Get the variance of a list.

• maxl() Get the maximum value of a list.

• minl() Get the minimum value of a list.

• workspace(): Prints all global variables.

• interp1(): Linear interpolation between two points.

• dot(): Get the dot product of two vectors.

• cross(): Get the cross product of two vectors.

• norm(): Get the norm of a vector.

• proj(): Get the projection of one vector onto another.

• reflect(): Get the reflection of one vector off another.

• reject(): Get the rejection of one vector off another.

• refract(): Get the refraction of one vector through another.

• angle(): Get the angle between two vectors.

• set_row(): Set a row in a matrix.

• set_col(): Set a column in a matrix.

• set(): Set a value in a matrix.

• kolasa(): Get the Kolasa matrix

• rref(): Get the reduced row echelon form of a matrix.

• rank(): Get the rank of a matrix.

• det(): Get the determinant of a matrix.

• transpose(): Get the transpose of a matrix.

• lu(): Get the LU decomposition of a matrix.

Removals

• Removed snap packaging support

• Removed wasm32-wasi target in build_multi.zig script, can still be built from source with:

  • zig build -Doptimize=ReleaseSmall -Dtarget=wasm32-wasi -Denable_fs=false -Denable_net=false -Dsandbox=true

Check Out the Release at [Github](https://github.com/Mustafif/MufiZ/releases/tag/v0.6.0) today!

The Mars release is going out of this world and will contain the following new changes:

• We have upgraded to Zig v0.12.0-dev and with this new toolchain, we hope this will reduce the future headache of migrating from v0.11.0.

• We have introduced the two following collection types:

  • Matrix: This multidimensional array allows users to create a multidimensional array. This type may also create a tensor where all elements are matrices.

  • FloatVector: This array strictly contains only double types and features using AVX2 for parallel operations. The size of 3 allows it to be used for Vec3 operations.

• More collection type builtins

• Networking Features: We introduce the following builtins for sending network requests:

  • get_req

  • post_req

  • put_req

  • del_req

• Random numbers of Uniform and Normal Distributions

This release, however, comes with the following removals or modifications though:

• wasm32-wasi is ran with enable_fs and enable_net disabled and has sandbox mode enabled so it runs on a REPL-only system.

• arm-linux-* toolchains have been removed due to issues with the LLD link when running on build_multi.py and will continually be tested to see if I can put the toolchain back in.

There is still a lot of code cleanup that needs to be done, and there are still differences between the implementations of the collection types. While making the builtin function arguments easier, type lookup for better error handling. I'd like to make build_multi.py to be smarter and help more with debugging certain toolchains, so this is why v0.6.0 is taking a lot longer than other releases.