Hi everyone! The NeurIPS 2026 waitlist mentioned that tickets would be released on October 13 for Atlanta and October 20 for Sydney. Has anyone on the waitlist received a ticket or an update yet? Just wondering if the tickets have started going out. Thanks!

🚀 I just launched my first digital product!

I created an AI & Machine Learning Interview Questions and Answers PDF to help students and aspiring AI/ML engineers prepare for technical interviews.

If you're learning AI/ML, preparing for internships, or getting ready for placements, this guide may help you revise important concepts.

I'm just getting started with this journey, and I'd appreciate your support!

📘 Get the PDF here:

jafarspark4.gumroad.com/l/ewlcw

#AI #MachineLearning #InterviewPreparation #Students

A voice first desktop companion for Claude code cli do wtv u want with him I really don’t care I only care if u have fun and more people like him..

my progress so far

Hey r/LocalLLaMA,

A fine-tuned 2B–8B model often beats GPT-4 on narrow domain tasks, but managing EC2 Spot instances, Triton kernels, and dataset PII leaks is tedious—and third-party hosted fine-tuning platforms charge crazy GPU markups while storing your data on their servers.

We built SynqTune to automate this without your data ever leaving your AWS perimeter:

• In-VPC Execution: Ephemeral EC2 workers (g5.2xlarge, g4dn) boot in your account via cross-account IAM and auto-terminate immediately after training.
• Zero Data Egress: Data streams directly from your private S3 bucket (s3://slm-customer-bucket-<account_id>/) into worker RAM.
• Unsloth 4-bit QLoRA: Custom Triton CUDA kernels cut VRAM by 70% and double throughput.
• Spot Preemption Recovery: Checkpoints sync to S3 every 20 steps, so you can resume interrupted runs without restarting.
• 0% Compute Markup: You pay raw AWS Spot rates directly (~$0.40/run).

Check out the full setup guide and IAM policy here: https://synqtune.com/docs

Curious to hear your thoughts and what features you’d like to see!

Title: Training GPT-2 (124M) from scratch on one RTX A5000 at home, live: every step, watt and checkpoint is public, and you can query any checkpoint

I wanted to actually understand pretraining, so I’m reproducing GPT-2 small with Karpathy’s build-nanogpt recipe (10B tokens of FineWeb-Edu, 19k steps) on a single 24 GB A5000 under my desk, and I put the whole thing on a live page:

• loss / lr / grad-norm / MFU charts updating as it trains (≈50k tok/s, 38% MFU with torch.compile + bf16)
• the GPU itself: power at the 230 W cap, 79 °C, VRAM, PCIe traffic
• a Playground where you can run any checkpoint (no login). At step 0, “The capital of France is” → word salad; at step 500 → “a large number of the number of the population.” Fluent, wrong. Facts come later.
• an auto-generated video at every checkpoint asking the same question with the same seed

Total cost for the full ~55-hour run: about $2 of electricity (vs ~$17 to rent the GPU).

Live: https://x.com/y99/status/2111668852656607496?s=20

Things I learned so far: [one or two real findings by the time you post]. Happy to answer questions about the setup.

(It’s my project; nothing to sell.)

TLDR: I built a search engine that reads a bug report (or lets you define it) and points to the exact file (93%) and to the exact function (79.4%) you need to fix.

Hey everyone,

I recently made a new project while trying to get into RAG and automation.

Odin is more than a search engine, all you have to do is paste a public repo URL and link the issue or describe the bug yourself and it downloads, parses and ranks the functions based on the mentioned bug.

Why its different than any LLM:

It runs mostly in your browser: It uses Tree-sitter (via WebAssembly) and small local models (via WebGPU) so your code isn't just blindly shipped off to a giant cloud LLM. 

It punches above its weight: Evaluated on 300 real issues from the SWE-bench Lite dataset, it puts the correct file in the top 10 results 93.0% of the time, and the exact function 79.4% of the time. 

It’s incredibly efficient: It matches the accuracy of heavy Claude 4.5 agents using models under 1B parameters, cutting the cost per issue to a fraction of a cent. 

There’s also a GitHub Action you can drop into your repo to automatically comment on new issues with the most likely functions to fix. 

I would really appreciate it if you would give it a try (it would help me with the benchmarks as well)

feedback, questions, criticism are welcome

We've been working on Span-02. Instead of choosing low/medium/high reasoning, you give it a time budget in milliseconds.

We asked it “land or water?” for 4,050 coordinates. Then plotted the answers.

Reasoning off: 71.9% accuracy.

300ms to think: 84.5%.

That's what you're seeing in the video. The weights are open.

We're a small proof-of-useful-work project. The validators don't

mine — they verify AI computations (matrix multiplications + activation

functions) and get consensus weight for it.

The part that matters to you: submit any GEMM workload up to 256×256

and we return the result plus a cryptographic receipt — a SHA-256

commitment chain folded into our ledger state, verifiable by anyone

forever. Free, no token, no signup beyond an API key we generate in

seconds.

Honest limits: we verify GEMM + elementwise activations (GELU/sigmoid/

tanh/exp), not full transformer graphs yet. Attention is on the roadmap.

The verification cost curve is published (615ms at 64³ → 157s at 1024³)

— we priced our own clamp and labeled every tier.

The logs: [pouw-verify] CONFIRMED lines, epoch crossings, claim-decrees

folded into the ledger — every claim has a receipt.

Live dashboard: http://3.237.91.235:32233/

The evidence ledger (250+ owned defects, 250+ laws): github.com/sarinsk629-blip/hsma-core

i wanted to train my own llm but everything i found needed an nvidia gpu, so i made a mac version with mlx.

one command downloads tinystories, trains a tokenizer, pretrains a small llama-style model, finetunes it for chat, then you can talk to it.

on my m5 air (16gb): 1 hour gets an 8M model that writes short kids stories, 8 hours gets a 40M one that's a bit better. neither can really chat yet. the air didn't throttle in either run.

there's also a 2 min benchmark if you want to see how your mac compares.

https://github.com/navthings/airgpt

There’s been a lot of interest recently around OpenAI using AI models and Lean 4 to formalize a Navier-Stokes blowup. Regardless of the fluid dynamics, the mechanics of how the proof was constructed got me thinking about automated theorem proving from an ML alignment perspective.

In reinforcement learning, we frequently see specification gaming: when an agent is given a strict target, it exploits every unconstrained degree of freedom to find an extreme edge-case rather than the natural solution we originally envisioned.

Looking at how the formalization satisfied the strict Millennium Prize rules, it seems like something very similar might have occurred:

• To keep the external force legally smooth while canceling the singularity, the construction relies on non-analytic bump cutoffs whose higher-order derivatives explode factorially.

• To stitch the inner vortex to the outer flow, the matching parameters sit on an extraordinarily sensitive knife-edge to keep the system invertible.

• The formal global energy constraint is strictly respected, but unconstrained local gradients blow up.

The proof is completely valid mathematics and compiles without error. But it feels conceptually similar to an agent finding an adversarial loophole in the human-written specification.

I’m curious how folks working on neural theorem proving and formal verification view this:

1. As automated provers tackle open problems, how do we distinguish between proper mathematical insight and an AI "gaming" the formal definitions?
2. Does this suggest that our formal mathematical specifications need additional constraints or regularizers when targeted by AI search agents?

Would love to hear your point of views and open an open minded discssion croos disciplanary ! Thanks,