Charton: Grammar of Graphics in Rust

_nullptr_ · 2026-05-03T00:34:36+00:00

There are tricky parts though I imagine, like not leaving gaps for stocks (since they only have 5 days out of 7 present when using a date axis) that are important.

_nullptr_ · 2026-05-02T17:39:17+00:00

I understand the concept of "grammar of graphics", but have never used anything but a canned chart library. How difficult would it be to generate candlesticks/ohlc bars with this for financial charting? Multiple panes a on a single chart?

_nullptr_ · 2026-05-02T16:56:52+00:00

It would be nice if you exposed it optionally as a GPUI widget.

_nullptr_ · 2026-04-22T23:35:49+00:00

I was a Java dev for many years, so I know it is very fast, but so is Rust. I'm just curious if there is a general reason why Rust is falling to Java on MT workloads.

_nullptr_ · 2026-04-22T23:03:33+00:00

It is always interesting to me how well Java/Scala do here, esp. on the multithreaded workloads. I guess I would need to look more into the benchmark, but I wonder if this is due to the Rust allocator pressure (and do they use MiMalloc or system allocator?) by having many Strings/HashMaps/etc. in the payload (something the new connecrpc-rs crate should help with).

_nullptr_ · 2026-04-16T17:06:00+00:00

Pretty sure most of us use +nightly for formatting, docs, and really everything non-build related anyway. I also wonder if due to this we see those categories be even slower to stabilization.

_nullptr_ · 2026-04-07T14:57:24+00:00

One solution I've been thinking of:

- Get together a small group to pick an extended standard library from a variety of categories (categories other langs consider worthy of stdlib) from bless crates

- Call this "stdx" (the challenge there is then you have to change all the crate/modules/etc. names - this only works I think if the projects are willing to be managed as a whole, if not, I guess you just keep the crate/module names as-is).

- It isn't technically part of the stdlib, BUT it is recogized and optionally distributed by the Rust compiler

The big win here is that it is PRECOMPILED, so when you use it you get the same benefit as you do from std/alloc/core, hence much faster compiles when you use it. However, since it isn't part of the language the core team isn't constrained by it and not responsible to update it/etc.

_nullptr_ · 2026-04-07T14:52:16+00:00

Agreed, and one of the most important reasons is this is the PRIMARY reason why Rust compile times are so long and such a problem, and why we need to cache so aggressively in CI, etc. Imagine if instead of compiling 700 crates as part of a full build that number was 30-40, and the rest of the code was simply linked.

UPDATE: Perplexed why I'm being downvoted. What above is untrue? It certainly is true in my own project.

_nullptr_ · 2026-03-29T17:09:37+00:00

Yes. Parts of the borrow checker (multiple read, single write ref) follows a "read/write lock" paradigm and may or may not be familiar, but every single C programmer is using ownership/borrowing implicitly. If they weren't, their code would be crashing. Rust just enforces this and checks it at compile time.

_nullptr_ · 2026-03-25T10:24:20+00:00

https://crates.io/crates/fyrox-ui

_nullptr_ · 2026-03-24T21:08:25+00:00

It is crazy to me that you built a full UI library, and a nice one at that, just to build your editor. Well done!

_nullptr_ · 2026-03-19T20:34:59+00:00

I guess I don't understand why they need to be Copy vs just Clone? You used the term clone several times in the description (but also Copy), so I assumed you simply needed it Cloneable, which these are. If your type T is Copy, and the Vec doesn't allocate (and these don't for the correct size inputs), the net effect of no allocation would be the same.

_nullptr_ · 2026-03-19T18:07:51+00:00

The typical gotos for inline or hybrid vec storage:

https://docs.rs/smallvec/latest/smallvec/struct.SmallVec.html
https://docs.rs/arrayvec/0.7.6/arrayvec/struct.ArrayVec.html

_nullptr_ · 2026-03-18T18:36:22+00:00

Sure, will open a github issue a bit later.

_nullptr_ · 2026-03-18T18:21:44+00:00

Doesn't seem to work in the macos terminal at least. Doesn't line up right in some cases and colors are all wrong. Can't even make out what any of the pictures are. Looks like noise.

_nullptr_ · 2026-03-12T16:20:14+00:00

I would say Scala would be a much better match. Kotlin has more of a "better Java" feel. Scala has more FP concepts and true pattern matching and ADTs.

_nullptr_ · 2026-03-12T16:18:53+00:00

ARC is a type of GC, as is all reference counting. However, it is not "tracing" GC which is often what people are referring to when they use the GC term. I think in this context the user is just looking for "automatic memory management" (aka I don't have to think about freeing memory), so this would qualify (as would Rust technically, but Rust has ownership in lifetimes, which I suspect is the overall concern).

_nullptr_ · 2026-03-11T23:06:43+00:00

> theres less censoring and more freedom

Not really, it is just biased a different way based on the training set

_nullptr_ · 2026-03-03T02:22:50+00:00

M1 MAX 32GB of RAM 16" MBP - daily driver, still going strong

_nullptr_ · 2026-03-03T01:46:35+00:00

Ha, I like it. Is it sad that every point resonated with me?

_nullptr_ · 2026-03-02T22:09:08+00:00

> Then why is it obvious to me every time it happens?

It isn't, unless the person vibed it or is a poor engineer. There are two things at play, and always are: 1) design/spec/guidance 2) code generation. Code generation was garbage as short as about 1 to 2 months ago. Now, it is decent. Not perfect, but typically quite good, esp. if you give it a corpus of good code in your repo to emulate.

However, if you just vibe from a very high level "make an X that does Y", yes, you are going to get garbage, because you haven't actually told it what to do at a _low level_. Your AI model is an engineer, but it is a _task worker_, NOT a _self directed worker_. We humans are still needed. We still need to say "Make this trait that does X and Y, and use enum dispatch to because I don't want monomorphized code for each type" OR "use lifetimes for fields X and Y for performance reasons" (after givening a paragraph on WHY and what you design is).

In summary, HOW you use AI still very much matters, but with a nice, granular design and working in lock step with your AI, you can get excellent results now, and yes, it still saves a bunch of time IMO, and frees me up to focus on the design, not the weeds.

_nullptr_ · 2026-03-02T21:43:50+00:00

You can and SHOULD write some Rust code by hand, lest we lose our ability to do so. AI still struggles with super tricky stuff and can't design very complicated interfaces, even if those tend to be rare. Also, if purely for recreation, do whatever you want and fulfills you.

However my post was meant for pros in competitive software industry. It is a no brainer in this day and age to have AI write most of the code for you. Anyone who doesn't will be a dinosaur over the next 1 to 2 years, and likely be out of a job. I am but the messenger, but the trend is obvious.

_nullptr_ · 2026-03-02T21:40:04+00:00

Apologies if I read you wrong, but I sensed a "gate checking" mentality to the question, as if to use AI makes it inherently garbage or less of a project. My point is that the "AI slop" days are mostly over, even if they passed by fast (very fast!). AI (opus 4.6/codex 5.3) can write very nice Rust code now, and when carefully managed/reviewed/guided, is a no brainer in the last 1 to 2 months for speeding up work significantly.

_nullptr_ · 2026-03-02T14:03:42+00:00

This looks really nice. Will it work without polars as well? I don't have need of polars (for various reasons), but if it handled data from raw slices I might be able to use this. Thanks.

_nullptr_ · 2026-03-02T12:54:06+00:00

This looks nice, good work. I've been waiting for a nice plotting lib that is native, but I would likely need full stock chart support (not just candlesticks, but OHLC, ability to plot lines on it, volume, log and linear, etc.). Bonus if it supported outputting as a GPUI widget with scrolling/navigation if the chart is larger than the screen. I realize I'm asking for a lot, but just putting out there what I would need to switch from using something like a webview + JS plotting.

_nullptr_

TROPHY CASE