Thank you for sharing this on HN.

It's a worthwhile effort. If successful, Woxi can enable a large mass of scientists and engineers who don't have access to Mathematica to run legacy code written for it. Also, Woxi would give those scientists and engineers who regularly use Mathematica a non-proprietary, less restrictive alternative, which many of them would welcome.

How does Woxi compare to other "clean-room implementations"[a] of the same language?

--

[a] Please check with a lawyer to make sure you won't run into legal or copyright issues.

There's a mystique around Mathematica's math engine. Is this groundless, or will you eventually run into problems getting correct, identical answers -- especially for answers that Mathematic derives symbolically? The capabilities and results of the computer algebra systems that I've used varied widely.

Hard to tell honestly. So far there was always some surprisingly straight forward solution If had any problems with the math engine. There is actually a lot of public research how equations can be solved/simplified with computer algorithms. So I'm optimistic. I also stumbled upon a few cases where Mathematica itself didn't quite do things correctly itself (rounding errors, missing simplifications, etc.). So maybe it's actually a little overhyped …

I also found problems with integrating some obscure functions a few years black, though IIRC the issue was remedies by using the amazing Rubi package:

https://rulebasedintegration.org/

Scmutils from MIT does a very good -- arguably better -- job for correctness. No symbolic integration by ideology and not identical. Sussman and Terman. Amazing attention to detailand correctness. Claude could probably bridge Scheme to Wolfram.

I'm not sure how important but- for-bug identical output really is.

Mathematica gets incorrect answers quite frequently.

How does it compare to mathics?

How close is it to being able to run rubi: https://rulebasedintegration.org/?

You can find the whole integration routine here https://github.com/ad-si/Woxi/blob/36343ab2cbc97e5081f7c811e.... It's essentially a test mock-up (not even trying partial fraction decomposition for rational functions).

    // ∫ tan(x) dx = -ln|cos(x)| - not implemented (requires Log)

This really doesn't bode well... I'm no expert in CASes, but everything I've looked at seems very naive. Vibe coding a Mathematica replacement makes zero sense to me.

Reported a few issues, e.g. https://github.com/ad-si/Woxi/issues/16

Interesting, thanks for sharing. Naive question as I'm not familiar with Mathematica much (but aware of it and Wolfram Alpha and related tools), how does it compare to e.g. Jupyter or Julia or maybe another language (with its framework) that might be even closer?

I think Wolfram Language is just so much more ergonomic. No need to import dependencies - everything's included and consistent, very readable - yet compact - syntax, less gotchas than Python, R, etc., sensible default, …

I'd add the pattern matching syntax. it's so natural for a mathematician.

Ymmv, but I've found that you sure do need to import things eventually, and it's not so ergonomic because most projects just end up as mega-notebooks.

Just like Python or any other language that looks easy for the learning examples, there are still hairy bits, they're just better hidden. The difference is that the debuggers for Python are far better.

Mathematica is great for quick stuff, but once you hit a particular level complexity it goes crazy. In this regard I find it similar to Bash.

What percentage of the overall code was written primarily by agents?

Why would I use this and not Wolfram Script?

Better license? Allowed for commercial operations?

License is a big deal, and not just for cost and openness, but also for practical use in pages like docker, ci/cd pipeline, cloud deployments, or other places licenses need to be dynamic.

Exactly! And:

- Faster startup time because of no license check

- Can run multiple instances of Woxi at the same time

- Embeddable via WASM

- Configurable via compile time flags (which features should be included)

- …

How is the popularity/rank in functions.csv determined?

That's actually a value that Wolfram determines themselves. Here is the documentation for it: https://reference.wolfram.com/language/ref/WolframLanguageDa...

Here is e.g. all the values for the Plus[] function:

$ wolframscript -code 'WolframLanguageData["Plus", "Ranks"]' {All -> 6, StackExchange -> 8, TypicalNotebookInputs -> 5, TypicalProductionCode -> 6, WolframAlphaCodebase -> 6, WolframDemonstrations -> 4, WolframDocumentation -> 4}

Have you considered using quickcheck/random/property-based testing with LLM code generation to automate function implementation?

Yeah, I've already looked into it, but decided to keep developing it "example driven" for now. Aka I'm playing around with it, and whenever I find something that's broken I keep a note of it and then I pick those notes one by one and implement them. Once the most common things are implemented I will start writing property tests to catch all the edge cases of each feature.

You accidentally raise an interesting point: good, thorough public documentation, once considered a great selling point for your system, now invites automated reimplementation by competition. It would be a shame to see public docs vanish because it turns out they are literally machine readable specs.

What is your plan for long term support?

LSP?

Not yet, but on the roadmap!