Marco Smith

We are entering a new era of on-device automation. ✨ Watch Gemma 4 E4B navigate and drive an iOS simulator directly using Argent. Local models can handle complex interactions and software navigation autonomously.

Qwen 3.6 models are now 2.5x times faster on Atomic Chat with new MTP speedups. > MTP drafts several tokens ahead and verifies them in one pass. The speedup depends on the memory moved per pass. Users can run Qwen 3.6 models locally via the open-source Atomic Chat to test them!

Fine-tuning local LLMs shouldn’t require renting a cloud GPU. Silicon Studio is an open-source desktop app for local LLM fine-tuning and inference on Apple Silicon Macs. It helps you prepare data, manage models, fine-tune with MLX, and test results in one local workflow instead of stitching together separate scripts and notebooks. Key features: • Native Apple Silicon path – uses Apple’s MLX framework for hardware-accelerated LoRA/QLoRA fine-tuning and inference on M1/M2/M3/M4 Macs • Data preparation studio – preview and edit JSONL/CSV datasets, strip PII locally, and convert CSV to JSONL for chat templates • Hugging Face model management – browse, download, and manage open-source models like Llama 3, Mistral, Qwen 2.5, Gemma, and Phi • Visual fine-tuning setup – configure learning rate, epochs, rank, and related settings without living entirely in config files • Local chat testing – switch between base models and fine-tuned adapters in a ChatGPT-like interface, with private/offline inference It’s open-source (MIT license). Link in the reply 👇

"Dive into Deep Learning" is an open-source book that builds the mathematical foundations of large language models, covering topics such as linear algebra, calculus, probability, optimisation, backpropagation, attention mechanisms, and transformer architectures. The book progressively moves from classical neural networks and convolutional neural networks to modern transformers and practical techniques used in large language models. With more than 1000 pages, it includes very clear explanations, practical examples, and exercises, making it one of the best free resources for understanding the mathematical structure underlying modern AI systems and LLMs. arxiv.org/pdf/2106.11342

A cool way to watermark network packets is to (very subtly) adjust the timing. Packet comes in a tiny bit late, maybe that’s a 0. Packet arrives on time? Maybe that’s a 1. Of course, the neat part is that everything can remain entirely encrypted / the side channel doesn’t “touch” the underlying data flow, so it looks relatively normal. You can actually get this timing to survive through multiple network hops + switches, because statistically they are (mostly) adding fixed delays. Queueing can mess you up, but as long as your information is above the network jitter noise, you can still decode it. There’s basically an arm’s race going on. Some networks attempt mixing flows with traffic shapers to preserve anonymity…but you also can’t infinitely pad/delay packets without users getting really annoyed. So, so many ways to hide a bit when you think about it. …also a lot of ways to detect it too.

Linus Torvalds doesn't think AI will replace programmers. Speaking at recent North America edition of Open source summit, Torvalds argues: "I'm personally 100% convinced that AI is changing programming, but it's not changing the fundamentals." Just as compilers increased productivity "by a factor of 1000," He estimates that "AI will increase your productivity by a factor of 10," but insists "AI is great, but AI is not changing programming." Instead, he contends, "a lot of people will use AI to generate the code that the compilers use to generate the code that the assemblers then use to generate the machine code. This is revolutionary in the same sense that we've seen revolutions before." Agree with him?

saying it out loud again. on a single 3090, the king is qwen 3.6 27b dense at q4, and nothing in that tier comes close. i've benchmarked the tier. happy to be wrong, so name the model that beats it. i just know you can't.

🐧 Linux Kernel is C 🌐 Nginx is C 🚀 Redis is C 🗄️ PostgreSQL core is C 🧠 SQLite is C 🔒 OpenSSL is C 📦 Git is C ⚡ Memcached is C 🧵 libuv is C 📡 TCP/IP stack is C 🖥️ X11 Window System is C 🧰 GNU Coreutils are C 🛠️ GCC is C 🧬 CPython runtime is C 📁 ext4 / NTFS file systems are C 🎮 Game engine foundations are C 🚗 Embedded firmware is C 📟 Networking drivers are C 🛰️ Aerospace & real-time systems are C 💳 Payment terminals run C The foundation of operating systems, databases, networking, crypto, and embedded systems is written in C. Trends come and go. C stays.

this got me thinking, what’s the most token-dense programming language? One that could fit the most program flow into the smallest context window? The winner, by a lot, is Array-Based Languages. J, K, that sort of thing. It’s actually a two-part problem, because you need something that is logically dense (saves length), but symbolically simple. Most tokenizers are optimized for standard text, so if you get *too* fancy with rare mathematical symbols like APL, token usage actually blows up! Python scores pretty well actually, but whitespace hurts you a bit. Haskell is an interesting outlier; it’s likely the most token-efficient statically typed language. Now, if you were to extend the problem assuming you’re making your own tokenizer and training a model to *specifically* be as efficient with program writing as possible… …you probably wouldn’t even use text. Just train/produce Abstract-Syntax-Trees directly, which would eventually start to look like compiler IRs / bytecode, which could eventually start looking like an ISA… and with hardware/software co-design we’d end up with CPUs where we don’t understand the execution at all ;)

Are you old enough to remember the golden age of text-mode DOS productivity tools? When hard drives were growing, users had to manage lots of files manually, and GUIs were still clunky or secondary/optional, many of these tools were hugely popular. If you had a PC in the 80s and 90s, I bet you had at least one of the following four. Peak popularity was probably between 1987 to 1994. XTree (and XTree Gold/Pro): Released in 1985 and was later called "perhaps the most popular DOS shell." XTree Gold (1989) was a massive hit, with over 3 million copies sold by 1991. Norton Commander (NC): First version from 1986, it became the "king" of DOS file managers in the late 80s/early 90s. It dominated through the mid-90s, with clones left, right, and center. PC Tools: Was a pretty strong competitor in the late 80s and early 90s, often second only to Norton products. It evolved into a full utility suite. Volkov Commander, DOS Navigator, etc.: These clones peaked in the early-to-mid 90s (Volkov from 1992 onward), especially on lower-end hardware where their speed and small size mattered most.

“if 64 bit is so good then why don’t we have 65 bit architectures” We kinda do, actually. Just mostly as hardware, not pointers. Intel Itanium’s general purpose registers were 65 bits; the last bit was known as a NaT flag. NaT stood for “not a thing”, which was a really interesting way of handling speculative execution. Basically NaT was a poison flag to say “hey this result might be garbage we’ll deal with it later”. Today we don’t really think about it, modern CPUs basically do all of their speculation in hardware…and throw out incorrect guesses without any user awareness. Itanium was essentially a bet that with enough primitives exposed compilers *might* be able to make better decisions at compile-time (versus say, hardware guessing at runtime). A (very) simplified way of putting it, is that on x86 you’re getting constant micro-stalls that the hardware deals with (…die space penalty), where *hypothetically* Itanium with a perfect compiler had no micro-stalls …but really, really bad macro stalls (NaT recovery is a sloooow software fix). Turns out, it was really difficult to write compilers that kept Itanium’s pipeline fed with anything that looks like a normal OS. But, it’s really interesting to see the general idea of “compiler handles the scheduling” coming up again with Cerebras (and arguably, the whole accelerator space)! We’ll see how it pans out… (Itanium was lovingly referred to as the “Itanic” by many)

Just found out an active File Pilot community member @thomasklemenc made a task manager inspired by it! Handmade from scratch, C++, win32, D3D custom renderer, 1.55 MB. More of this in my feed, less AI slopware.

flip-flops and logic gates are where computation starts. not ai. not python. not react. not operating systems. just voltage. high voltage → 1 low voltage → 0 that’s it. logic gates are the decision makers. and gate → both inputs must be 1 or gate → one input must be 1 not gate → flips 1 into 0, 0 into 1 xor gate → true only when inputs are different from these stupidly simple blocks, you get: → adders → multiplexers → alu → registers → memory → cpus → gpus → basically the entire digital world but gates alone are not enough. logic gates compute. flip-flops remember. that one distinction is the whole game. a logic gate says: “given these inputs, what should the output be right now?” a flip-flop says: “store this bit and hold it until the next clock edge.” that’s memory. one flip-flop → 1 bit 8 flip-flops → 1 byte 32 flip-flops → one 32-bit register millions/billions → real machines this is where circuits stop being dumb wires and start becoming systems. combinational logic: input → logic gates → output sequential logic: input + previous state + clock → next state that “previous state” is everything. without flip-flops: → no counters → no registers → no instruction cycles → no finite state machines → no processors → no computers software people think computation starts at code. hardware people know it starts at state. code becomes instructions. instructions become control signals. control signals move bits. bits sit inside registers. registers are built from flip-flops. operations happen through logic gates. every app, every website, every model, every game, every “ai agent” eventually collapses into this: gates deciding. flip-flops remembering. clock ticking. learn digital logic once and computers stop feeling like magic. they become machines.

RE tip #19412 C2 isn't always encrypted - sometimes it's just sitting in dead space inside the PE, stored in network byte order, the bytes are already laid out in the order connect() wants... 0x92 , 0x67 , 0x6a , 0x3b = 146.103.106[.]59 0xc3 0x68 = port 50024

Writing an ARM64 bind shell that chains six syscalls without a single null byte: 8ksec.io/arm64-reversin… x0 is shared on ARM64, it's the syscall return register and the first-argument register. The socket fd can't stay in x0 across six calls, so it parks in x4 and reloads when needed. Then the null-byte constraint kicks in. LDR pulls from the literal pool, MOV #0 encodes zero, SVC 0 introduces a null byte in the immediate. Fixes: ADR, MOV xzr, SVC #0x1337. 144 bytes, same chain, no zeros. Check out the series at 8ksec.io/arm-64-reversi…

Bell Labs built an operating system so weird it could run inside another operating system. 🤯 > They called it Inferno OS. > Built in 1995 at Bell Labs. > The same lab that created Unix, C, and the transistor. > Designed around one crazy idea: “everything is a file.” > Networks acted like files. > Hardware acted like files. > Even running programs looked like files. > One simple system controlling everything. > Could boot as its own OS. > Or run inside Windows and Linux like a normal app. > Same software worked everywhere unchanged. > No recompiling. No platform headaches. > Bell Labs pushed it against Java in the 90s. > But Inferno went further than Java ever did. > It made the entire operating system portable. > Ran comfortably on just 1MB RAM. > Built for TVs, routers, and embedded systems. > Long before IoT became mainstream. > Never became popular despite being years ahead. > Open sourced in 2021 for anyone to explore today. Most operating systems chased popularity. Inferno chased ideas that were too early for the world. One of computing’s most underrated projects ever. 🔥

I've been coding for 40 years. Here are the top 5 things I wish I knew when I started. 1. 90% of the job is debugging and fixing, not creating new code. Which is still fun if you're good at it. I used to think programming was mostly writing fresh, clever stuff. In reality, most of your time is spent in other people's (or your own past self's) messy code, chasing down why something that "should" work doesn't. Get really good at debugging early. Learn assembly reading, call stacks, and kernel debuggers. It pays off hugely. The best engineers I saw were absolute magicians at this. 2. Manage complexity from day one (ie: don't write slop and "fix it later" if it goes somewhere). Very early on, I'd hammer out code and refactor afterward. Big mistake. Now I start with clean, skeletal structure (minimalism first) and flesh it out carefully, with AI or not. Messy code compounds and becomes unfixable. Upfront discipline on architecture, naming, and simplicity saves enormous pain later, especially in large systems like Windows. 3. Tools and processes matter more than you think We suffered with basic diff/manual deltas instead of modern source control like Git. Branching, testing, and good tooling would have made porting and collaboration way smoother. Invest in your environment, automation, and reproducible builds early. Good tools amplify your output; bad ones (or none) drag everything down. 4. Understand the problem and existing code deeply before writing Don't jump straight to coding. Map out the problem, study what's already there (you'll inherit a lot), and plan. Low-level knowledge (hardware quirks, alignment issues on different architectures like MIPS/Alpha) was crucial. Also: assert early and often. It forces clarity. 5. People, politics, and "the right tool for the job" beat pure tech arguments. Brilliant engineers still argue endlessly. Sometimes it's about ego, not merit. Learn to spot the difference and "steer" the conversation rather than "winning" it. Bonus from experience: Side projects like Task Manager (started at home because I wanted the tool) can become your biggest hits. Ship small, useful things often. If you're just starting, focus on fundamentals, patterns over syntax, and building resilience for the long haul. It's going to be a wild ride, but the fundamentals still matter.

New in Claude Code: agent view. One list of all your sessions, available today as a research preview.

most common neural net mistakes: 1) you didn't try to overfit a single batch first. 2) you forgot to toggle train/eval mode for the net. 3) you forgot to .zero_grad() (in pytorch) before .backward(). 4) you passed softmaxed outputs to a loss that expects raw logits. ; others? :)

CPUs tend to get slower with time. Probably not for the reason you’d expect. Unfortunately, many microcode updates are security related, which almost universally cause performance regressions…or even complete feature loss! Haswell might be the worst performing processor family of all time, in terms of features removed. TSX - concurrency instruction literally removed due to security concerns DX12 - removed / broken due to priv escalation Meltdown, Spectre, Foreshadow, MDS - all lead to perf regressions…for MDS specifically Red Hat and Microsoft still suggest disabling HyperThreading on Haswell! Over the life of a CPU, I’d expect the typical performance curve (from microcode) to look like: Initial Launch to +1 year, slight upward trend, platform maturing 1-2 years, mostly flat 2+ years, likely downward trend. Enough time has passed where security people are starting to poke/write papers indirectly leading to vendor microcode regressions 6+ years / EOL -> old CPUs start to have major regressions! I genuinely wonder if extremely performance-sensitive industries sometimes purposefully delay or otherwise remain on “stale” microcode…and just accept the additional risk.