onlyrealcuzzo

This is awesome, but tokenization is typically <0.1% of total inference time.

Presumably there's a host of applications that just need to tokenize, though, and this would be great for those!

2030: scan your asshole to make a commit so we know you're a human.

In my experience, Fable is not even close to Sol 5.6 High (not even the max tier) for coding.

1) it's substantially slower.

2) it's substantially more expensive.

3) it's code is considerably worse.

It's a joke when you consider what you get for what you pay for.

It's rumored that Gemini 3.5 flash has a >50% margin, and I'd imagine 3.6 flash is even higher.

I do not think OpenAI or Anthropic are actively chasing margins - though, Anthropic is supposed to be profitable on some form of non-GAAP accounting...

I suspect Google isn't really interested in seeing how far it can get dragged into a race of selling dollars for $0.25, and is more interested to see if it can stay in the race selling $0.50 for a dollar - when everyone else is losing or barely breaking even.

Gemini 3.5 flash is already a pretty good model. But, unfortunately, the primary way you can interact with it for coding is through Antigravity - which is actively developer hostile.

It doesn't matter how good the model is if you're (mostly) forced to use it in Antigravity - which turns any model into crap.

Wake me up when Antigravity doesn't suck.

Put all of these trends together, and I think that in 10-15 years, we are going to have consumer PCs (and phones!) running models doing pretty much anything that frontier models can do right now.

Phones are constrained by battery power and memory does not shrink as fast as CPU/GPU, so unless there's a battery breakthrough and/or memory breakthrough, you're not fitting 100Gb of RAM on your phone in 10 years.

Absolutely in a Mac Studio equivalent.

LLMs have emergent capabilities when they get smarter. So who knows how insanely big frontier models might be at that time, or what their capabilities may be.

So if I write one line of code in a 1M line LLM codebase, is it mine?

I'm working on porting the Rust compiler to VB.NET, so I can run it inside Excel spreadsheets.

And so it's "actually memory safe".

/sarcasm in case not obvious.

I would suggest to people using LLMs: you should be cautious about giving these companies data or relying on them. If you're building an AI startup, there's a very good chance they could decide to directly compete with you if your idea has traction. You're also at their mercy for API pricing etc.

LLM generated code is not copyrightable, so even if they do "steal" it - I don't think there's legal grounds to do anything about it.

It can't be stolen. You don't really own it.

You can try to lock it in a safe and hope no one ever gets a hold of it. You can lie and say you didn't use an LLM, but Anthropic and OpenAI et al probably have logs to disprove that.

But, if push comes to shove, you don't own it...

It's kind of crazy what goes on in that machine. It basically turns into a mini-Venus in there.

If rewrites are so easy, why not rewrite CC in a native language? Would’ve been a hell of a lot cheaper.

It was unpleasantly surprised when I learned the hard way that LLMs are not much better at translating than writing from scratch.

The more you look into how they work, the more you see that it doesn't really give them a huge advantage, if the classes are big enough. You can tell them to break each function up and translate them one-by-one, but the errors compound, you can't test most of it until you have a lot done, and in the end, it really isn't much faster (and sometimes it seems to be a lot slower) then just telling them to start over from scratch.

The downside is... If you have a system that already works, you don't want to start from scratch and test everything all over again...

Buys $10 worth of credits.

Codex, translate the entire PostgreSQL codebase to idiomatic Rust, make no mistakes.

The TL;DR delivers:

Researchers found AI advice suppressed judgment suspension from 44% to 3%, accuracy from 27% to 9%, while confidence rose from 30% to 76%. People trusted wrong AI answers.

I didn't see the article mentioned what they were actually asked, but I'm surprised confidence was only ~30%.

How about an animated SVG of a pelican doing the Macarena, profile view, spinning to face the camera on the last beats?

Who do you buy DeepSeek from?

I bought it through OpenRouter and used it with Pi agent.

The model was good, but there appeared to be a pricing glitch or something, because it burned through $50 in under an hour on pretty trivial stuff.

Pi agent claimed it only used like $1. OpenRouter claimed differently and said I used all $50.

Nassim Taleb has statistically proven that there is only a handful of investors ever who's returns over the market average can't be explained by random noise.

That doesn't prove there is no such thing as "talent" wrt investments, but it is proof there is almost no proof anyone has "talent".

China never allow US AI in China, so they HAVE to build Chinese equivalents...

US immigration policy isn't a big factor.

China's got 1.8B people. If you don't think they've got the talent to pull this off, even if a lot of it leaves to live elsewhere, you're naive.

No one uses Baidu, but they built their own Google, and it's good.

They built their own Facebooks and Instagrams.

The US isn't the only place in the world where people can build software...

You either do it with Linear Types, Affine Types, or you have holes...

Or you've invented a novel new system and should be publishing white papers immediately.

You can do virtually everything Zig comptime does in Brute Force in C++23. If this was possible - completely, it would already be done for C++. You need to point out exactly what you can do in Zig that you can't in C that somehow magically makes this completely possible and bulletproof in Zig - otherwise, you have a "concept of a plan".

The reason Rust sucked the air out of the room is that people are much more interested in systems without holes than systems that mostly work, or partially solve small parts of the problem and/or rely on the developer getting it right.

I hope you're right, but hope is a bad strategy.

By all means - reach out when it's ready and I'll give it a test.

I'm highly skeptical you can get it to work. If it was easy and optional and non-invasive and actually worked - the Zig team would almost certainly build it.

But, even if it just mostly works - that would still be very useful if it's non invasive.

zig in particular is easy (disclaimer: i think, i haven't implemented it yet)

I guess it's "easy" compared to other languages - but if you think it's "easy", we have different definitions of "easy".

You could implement it, but it would look like efforts in Rust to get SPARK-like safety, and SPARK itself. It will essentially be a different language.

You will not be able to work seamlessly with any regular Zig code. That may or may not be a problem if you're willing to assume you can just use it all unsafely and it works enough that things are fine.

That's somewhat analogous to unsafe Rust. The difference with unsafe Rust is... That's a very small fraction of what you're using, not the vast majority of what you use.

When you use a Rust crate - you generally do not expect that it could have infinite race conditions. It may have some unsafe code, but that should be the exception, not the norm.

By all means, please build it. I'd consider using it [=

Well... The fact that it took 10x longer for Doom to build than the language tells a lot.

Doom is not harder to re-implement than a language.

The language does not "work" by any sense of the word - which is why it took Doom so long to implement.

You could get GPT to "self host" a "language" in 5 hrs. That's not impressive.

The language actually working and being non-trivial would be in 20x the time.

Sure, GPT can build yet-another-Lisp in 2 minutes. You could copy Lispy yourself in that time: https://www.norvig.com/lispy.html

GPT/Fable/what have you is not building this language, as its laid out, and "working" in a true sense that fast.

Either OP is completely full of it, the language didn't actually work (and likely still doesn't), or the language is far less sophisticated than it seems from the examples - it's and the examples are minimal, so it's kind of hard to tell what it actually does...

Allocations are less of a problem than aliases.

Without affine/linear ownership - solving the aliasing problem is the Halting Problem.

Rust didn't invent Affine Ownership just to make Rust hard. It did it because it's one of the only ways to have memory safety without a GC.

I'm pretty sure Zig has no plans to ever become safe - by any sane sense of the word - so, yes, I would expect...

It's literally the most sophisticated scheduling engine in the world.

In practice, Go can typically outperform Rust in throughput (using more memory), despite having a mountain of disadvantages against it in theory.

That's how good the Go scheduler/runtime is.

That's sort of what I'm doing...

I'm writing a language with Affine Ownership that transpiles to Zig and has a built-in FSM-based Green Fiber runtime.

Affine Ownership gives you memory safety + fearless concurrency + eliminates the need for Go's GC.

It's obviously going to slow down compilation - since you need to do Rust's borrow checking, etc. But I can do this incrementally as well...

Zig's incremental builds are DEFINITELY a killer feature. In the short term, I could see why you'd make a switch to get it. But, in the medium term, can we really not expect to see this in Rust in the somewhat near future?

I want to go fast, but I don't want to go fast just to shoot my foot off.

If only somehow we could get Rust's safety with all of Zig's features and Go's runtime without GC...

That's what I'm working on building [=

Just trying to offer some help here, not an attack:

``` G# brings Go-, Kotlin-, and Swift-style ergonomics — packages, func, data class, nullable handling with if let, structured concurrency with scope — to the .NET runtime. Source compiles directly to managed assemblies. ```

This is a decent description - but as someone also building a language in a similar space - who isn't super familiar with the .NET runtime... My first question is... Why not C#?

I'm by no means a C# expert, but I thought most of this was supposed to be in C#. C# is not terribly un-ergonomic, and Go is simple, but not really ergonomic except for Goroutines...

`packages` and `func` being the first two selling points is alarming. Sure, people probably prefer `fn foo() -> Dog` over `Dog foo()`. No one's picking a language for that. C# has namespaces... C# has `record` and `record struct`. C# has not-ideal nil handling, but it still has it. I'm not convinced `if let` is better enough to be a selling point - a lot of people don't like that!

Your main selling point seems like `scope` and your concurrency model vs C#, but C#'s is not exactly terrible...

Rich Hickey has a joke about semi-colons in language design, and your main pitch seems to sell yourself short.

Btw, I think your GitHub page does your language a lot better justice.

It's like English... But with worse sigils than Python...

I mean - the idea that any company employing non-trivial amounts of people "cares" in any sane sense of the word "care" is absurd.

Who is supposed to "care" about you? A single person, definitely not the CEO, is going to individually care about 20k+ workers, especially not 200k+ workers.

Even if you assumed an altruistic HR department, it's still going to be a faceless blob when you're a 100k+ company.

So many "Look what my LLM did now" posts.

Back in my day, we used to walk 15 miles up hill, BOTH WAYS, just to get to school...