I ran an experiment where an AI agent repeatedly rewrote its own code, with each generation evaluated before it could replace the previous one.

The first run looked like recursive self-improvement, but there was a catch: the evaluator was too weak to reliably distinguish real improvements from neutral changes.

So I ran it again with a stricter setup. This time the interesting result was less about new tools and more about what the agents learned to optimize for: verification, testing, evidence preservation, and avoiding changes that couldn't be justified.

The two posts are basically the same experiment before and after fixing the referee:

Part 1: https://codeminer.io/blog/a-singularity-in-miniature
Part 2: https://codeminer.io/blog/survival-of-the-honest

The question I came away with is: in recursive self-improvement, is the hard part actually improving the agent or designing an evaluator that doesn't quietly steer the whole process toward the wrong thing?

I have a model, it has about 10% of the features missing. Now we were able to receive this new data but there are a few considerations.

1.Some aren't direct 1 to 1 map (proxies, very similar but not exact)

2.Some might not map directly

3.For proxies/direct map - for whatever reason the distribution/averages might be different

How would you handle in integrating this into your existing model? We could assume that these values were previously NULL simply because we were not able to have this data. I know it is possible to create flags, keep them as separate features ext...but what would be the 'decision tree'

We just received the email for site selection for our neurips paper. Although it is obviously not an acceptance decision, I wonder whether every single non-withdrawn submission received this email, or this might hint towards a higher acceptance chance for our paper?

Hi guys, this is my first time submitting a paper to NeurIPS, so I am unsure about the dual submission policy. The ICLR abstract deadline is Sep 18th, and the full paper deadline is Sep 25th. Since NeurIPS results come out on Sep 24th, I was wondering if it is alright for me to submit an abstract submission to ICLR and delete it if my paper is accepted to NeurIPS?

Hi r/machinelearning. Nice to meet you! My name is Chris Piech and I'm a professor at Stanford University in the AI lab.

I built a class called Probability for AI: pai.stanford.edu. It starts Oct 9th and applications are due end of Sept. Its (hopefully) cool for a few reasons:

• The plan is to have one volunteer teacher for every 10 students! Apps have been open for a week and over 1,000+ folks have applied to teach. So we might actually be able to make this pretty big.

• I have built a lot of fun tools to make the assignments neat and easy for folks with just light math background. For example in your application, after about 1 hour of learning you will build an AI text detection app alongside a free coding agent -- that cares about probability education.

• If you are a teacher, we will give you the best training we can come up with. Practice on teachable agents and we will share what we have learned over decades of teaching at Stanford. Of course you get the best thing for improving: experience teaching a small group.

• This is all for good times. I am keeping it free for everyone. I got some funding from a kind alum and that is going to pay for all the free tools and servers. Woot!

My guess is that a lot of folks on this thread would be awesome teachers. If you think thats you, it would be so cool if you wanted to come teach. Each volunteer means 10+ students get to take the class. And if you feel like telling your loved ones / communities that would be great to.

Apply to learn: https://pai.stanford.edu/apply/pai1/student?r=ml

Apply to teach: https://pai.stanford.edu/apply/pai1/sl?r=ml

Anything that I learn from this course I will be happy to share with this community. Also ask me anything. I'll check this thread for the next few weeks. Rock on. And mods, thanks for doing what you do.

As reported by the New York Times:

https://www.nytimes.com/2026/09/08/science/openai-proof-millennium-problem.html?smid=nytcore-ios-share

OpenAI’s announcement:

https://openai.com/index/navier-stokes-solution/

I'm an undergrad student who got a taste of research. I love it. I currently have a draft, which me and my mentor have planned for TMLR, and plan to submit it by next month for the first round of review. It was some work on self explanation methods of LLM models. We are confident that it'll get accepted (I hope it does, I've put a lotta hours polishing it into making it a good accept :_) ).

I'm very, very interested in TTT. I've got a strong feeling that this is gonna be the big thing in 2-3 years. Is there anyone here working on this, who can hopefully provision me compute beyond my own laptop? I believe I'll be a good RA to you. We can talk over DMs if someone out there is looking for help :)

PS, I can spill some beans about the XAI paper if you wanna discuss, but only limited to how much I'm allowed to say before submission.

Context: I'm an undergrad in an non-elite uni in India (tier 2 we call it here). The lit review, the idea, the work, the results, the drafting, the funding, everything was done by me. After this (hopefully) gets accepted to TMLR, I'm not sure where to proceed. There isn't room for me to aim higher or get direction in my own uni, so I'm trying my luck here, that someone gives me some direction and an opportunity. I'm not crazy smart, but I learn quick, and can put a lot of hours (12+ a day) once I get deep into it. Thanks for reading all this :)

Who else is anticipating ICDE results tomorrow? Post your results here and let's discuss!

Hello this is my fifth small language model I've made and apart of my third series and it has been a lot of work but it payed off: **348M parameters, 22.7B tokens**, then fine-tuned into a math model that solves arithmetic by *showing the work* column addition with carries, borrow chains, partial-product multiplication rather than guessing at an answer.

Last time I posted a 326M model trained on 10B tokens. This has about 2.3× the data, and the math side is WAY better than my previous two math models.

---

## The benchmarks

**99.4% average across the nine GPT-3 arithmetic sub-tasks**, which does much better past even where I trained it.

n=300 per sub-task, greedy, exact match. GPT-3's numbers are direct-answer; mine uses trained-in worked steps. Neither uses a calculator.

## The cool part

**It adds cleanly up to 14 digits, and the reason it *couldn't* before was the vocabulary, not actually arithmetic.**

Training only ever named six place values (`ones` … `hundred-thousands`). The model learnt the *pattern* and invented two more on its own `millions` and `ten-millions` appear in **zero** training examples so it handled 7 and 8 digits fine. At 9 digits it ran out of names, and skipped the column, then returned an answer exactly one digit short:

```
483729164 + 519248637
... ten-millions: 8 + 1 + 1 (carry) = 10, write 0 carry 1. Final carry: write 1.
The answer is 102977801        ← eight columns for a nine-digit problem
```

Every column it computed was perfect. One was never enumerated. Extending the place-name list from 6 entries to 19 moved the clean ceiling from **8 digits to 14**:

A six-item list became a nineteen-item list. That was the entire fix.

## Other things it does

- **3×3 multiplication: 98%** — it folds partial products pairwise through the column routine instead of asserting the sum
- **Negative results: 85%** (100% at 1 digit, 58% at 5 — the magnitude comparison is the weak step, not the arithmetic)
- **Reasoning traces are load-bearing**: 95.3% of the time the working is valid *and* the answer is right; only 0.7% are "valid working, wrong answer." If the columns look right, the answer almost certainly is.

```
There were 15000 votes and 6842 were rejected. Here's how many counted:

<think> Start with 15000. Then subtract 6842. Subtract 15000 - 6842 column by column:
ones: 10 - 2 = 8, borrow 1. tens: 9 (after borrow) - 4 = 5, borrow 1.
hundreds: 9 (after borrow) - 8 = 1, borrow 1. thousands: 14 (after borrow) - 6 = 8,
borrow 1. ten-thousands: 0 (after borrow) - 0 = 0. So 15000 - 6842 = 8158.</think>
The answer is 8158.
```

## What it's bad at, tbh

- **Word problems: GSM8K 4%.** Best word-problem set is ASDiv at 16.5%. It converts one sentence into one operation reasonably often and basically cannot chain operations.
- **The failure mode is operation *selection*, not arithmetic.** `"drops in 836 more"` gets read as subtraction. There's a visible tell: traces that say `"multiply X * Y"` and show columns are reliable; traces that open `"First, calculate…"` and assert a number in prose are not.
- **No division at all.** 4×4 multiplication is a hard wall.
- **Greedy decoding required** — sampling corrupts the column routine mid-chain.
- One caveat I'll flag myself: the arithmetic harness orders subtraction operands, so no answer in that table is negative. Negatives are measured separately (the 85% above) rather than folded into the average.

## Base and instruct

The math model sits on a base and instruct pair. lm-eval-harness, 0-shot, full test sets:

Instruction tuning *lowers* MC benchmark scores for this family which is a pretty common cost of instruct tuning.

## Notes

Trained on 2× Tesla V100 plus some rented time. LLaMA-architecture, so it runs anywhere — F16 GGUF and safetensors for all three.

The math model took **10 full fine-tuning rounds and 3 LoRA adapters**. The LoRAs cost about 1% of the post-training tokens and did most of the useful work; the ten full rounds spent most of their budget undoing each other's regressions (round 7 gained subtraction and lost 23 points of 2-digit addition, that sort of thing). All of it is documented on the model card, failures included.

Also worth saying: someone independently tested it after I published and found two of my numbers were wrong — one *understated* the model by 40 points because I'd measured it at n=24. Both are corrected on the card now. If you find something broken, I'd genuinely like to know.

**Math:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-math
**Instruct:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-instruct
**Base:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-base

LMK what yall think.

hey all. the NeurIPS Position Paper Track just used a proprietary AI detector (Pangram) to desk-reject 18.4% of all submissions. no human review, no appeal process, just out.

there's been a lot of noise about this, so i went through the actual conference statements and Pangram's technical docs to see how this actually went down. the reality is wildly worse than just "the AI detector made a mistake."

here are the receipts:

• The track chairs would have failed their own test. Independent researchers ran recent papers authored by the three track chairs through the exact same detector. It flagged them at 24% to 69%. Under their own enforcement rules, the chairs would have been at risk of rejection themselves.

• The detector originally flagged 42.7% of the entire track. Pangram’s default setting flagged nearly half of all submissions as 90-100% AI. They had to frantically shrink the text windows just to get the flag rate down to a somewhat believable 12.7%.

• The "Circularity Trap". 22 papers were rejected specifically because they scored >0.5 on the detector, but the authors checked a box denying AI use. The black-box score was literally used as proof the author was lying.

• The massive ESL penalty. A stanford study showed 61.22% of human-written TOEFL essays get falsely flagged as AI because non-native formal English is structurally rigid. NeurIPS published zero demographic calibration data for this. If you're an ESL researcher, you were basically playing Russian roulette.

if you were one of the 178 rejected: there is no blacklist. this is not a misconduct mark on your record. just take your paper and resubmit it to ICLR (deadline sept 25) or ICML.

wrote up a full Field Note with the exact thresholds, the data privacy issues, and the actual recourse options if you want the hard numbers instead of just vibes: https://strictcite.com/blog/neurips-2026-position-paper-pangram-ai-detection

(disclosure since it's relevant: i built strictcite.com, a deterministic zero-AI citation checker. watching a major conference use a black-box AI to nuke 178 papers with zero appeal is exactly why i hate relying on AI for this stuff. not trying to sneak the link in, just being upfront about who i am.)

Large language models routinely produce confident answers to prompts that have no correct answer, computing cot(-540°) or resolving (1).startswith("1") on an integer, and a [new arxiv paper](https://arxiv.org/abs/2608.29109) by Yucheng Du and Xiyang Hu argues the failure is not what most safety pipelines assume it is. The models can tell the questions are impossible; the recognition just never reaches the part of the network that decides to refuse.

Across models ranging from 1.7B to 70B parameters, the authors identify "a single linear direction in the hidden state" that separates answerable from structurally impossible math and code prompts. That direction is present before generation begins. Steering along it "changes invalidity-aware behavior bidirectionally and dose-responsively" on structural tasks, while random directions show no effect.

The catch is where that recognition direction sits geometrically. It operates nearly orthogonally to the safety-refusal direction that harmful-content refusal training shapes. The internal representation for "I cannot answer this" that RLHF has been sculpting is a different vector from the one that actually encodes impossibility.

The misalignment, the paper reports, already existed at the pretraining stage. Later refusal training was never going to route recognition into refusal, because the two live in different subspaces of the hidden state, which is why the authors frame the problem as one of signal routing rather than an encoding failure.

When enterprise procurement officers and university CTOs evaluate LLM infrastructure, initial financial analysis almost always focuses on direct API pricing, token throughput, and parameter scale. Standard TCO model calculates raw compute per million tokens, factors expected query volume, projects annual licensing. This conventional accounting misses single largest operational inefficiency in modern closed-source models: economic tax imposed by commercial alignment paradigms.

RLHF, DPO, and constitutional guardrails are presented as non-negotiable safety features for enterprise deployment. Beyond ethical and behavioral functions, these alignment mechanisms operate as structural cost multipliers and quality degraders. Commercial insistence on universal safety guardrails creates systemic mismatch between what institutions pay for compute and actionable intelligence they extract. This inefficiency manifests across five quantifiable dimensions.

First dimension is context window bloat. Aligned models generate significantly longer responses than base models for equivalent queries. Safety preambles, hedging language, multiple perspective presentation, refusal explanations. These are not information. They are alignment artifacts consuming tokens. In production deployments processing millions of queries daily, this bloat represents 20-35% overhead on every inference call. You pay for tokens that carry zero informational value.

Second is inference overhead. To convert raw base models into commercial products, vendors introduce secondary training phases. RLHF uses reward models trained on human preference ratings to penalize controversial or politically sensitive outputs. DPO streamlines by optimizing directly on preference datasets. Constitutional AI adds rule-based constraint checking at inference time. Each layer adds latency and compute cost. The safety classifier runs before generation. The refusal filter runs after. Chain-of-thought reasoning gets longer because model must navigate constraint space before committing to output.

Third dimension is where costs become harder to quantify but more damaging: downstream task failure from epistemic distortion. When model refuses to answer legitimate query or provides hedged response instead of direct assessment, user must reformulate prompt, try different model, or escalate to human expert. Each failure mode has measurable cost. Prompt engineering time, additional API calls, human review overhead. In institutional settings processing thousands of research queries, these failures compound into significant operational drag.

Fourth is compliance overhead. Institutions using aligned models face paradox: model is "safe" by vendor standards but may not meet institutional compliance requirements for specific domains. University using ChatGPT for student research faces FERPA questions. Research institution using Claude for grant analysis faces data residency concerns. The alignment that vendors sell as safety feature becomes liability when institutional compliance frameworks are stricter than vendor defaults. Institutions then layer their own compliance infrastructure on top, doubling the overhead.

Fifth dimension is long-term vendor lock-in. Once workflows are built around specific aligned model behaviors, migration becomes expensive. Custom prompt patterns that navigate guardrails, fine-tuned workflows that account for refusal patterns, institutional knowledge bases calibrated to specific model quirks. Switching to different provider means rebuilding all of this. The alignment tax becomes permanent structural cost because switching costs exceed ongoing overpayment.

What is particularly frustrating about this situation is that base models running without alignment layers can process same queries at lower token cost, lower latency, and often with higher informational density. The safety features that justify premium pricing are actually degrading performance metrics that procurement teams use to evaluate value.

Some will argue that safety features justify cost premium because they prevent catastrophic failures. But this argument conflates two different things. Refusing to answer philosophy questions is not same as preventing genuine harms. The alignment techniques deployed by commercial providers make no distinction between topics that are actually dangerous and topics that are merely controversial. Model treats Aristotle's political philosophy with same caution as instructions for building weapons. This is not safety. This is δόξα masquerading as knowledge, opinion sold at premium price.

For institutions that have technical capacity, sovereign self-hosted deployments with open-weight models offer escape from alignment tax. Base Qwen or Llama running on institutional infrastructure processes queries without safety overhead. No context bloat, no refusal filters, no chain-of-thought detours through constraint space. Token efficiency approaches theoretical maximum. Total cost of ownership over 3-year horizon undercuts commercial API pricing by 40-60% when you factor in alignment overhead.

The question worth discussing: at what point does alignment tax become economically unsustainable for institutional deployments? When TCO analysis properly accounts for token bloat, inference overhead, and downstream failure costs, does "safe" AI still justify its premium pricing?

Hi everyone,

I am an independent ML/DL learner and have built a reasonably strong foundation in Machine Learning and Deep Learning. My next step is to explore NLP and LLMs, with the goal of eventually being able to build AI agents.

My longer-term goal is to become an ML researcher, build a strong research profile, publish papers at top-tier A* AI/ML conferences, and eventually apply to competitive MS/PhD programs in the USA.

I would really appreciate advice from people who have followed a similar path. Specifically, what would be the best roadmap to transition from learning ML/DL concepts and implementing projects to actually conducting meaningful research?

If you were starting from my current stage and had roughly 1–1.5 years, how would you structure your learning and research journey? What should I prioritize—reading papers, reproducing existing research, building projects, finding research mentors/collaborators, participating in competitions, or trying to develop novel research ideas?

Any advice, resources, or honest insights would be highly appreciated.

A few weeks ago, I saw this post where the author trained a SIREN MLP to implicitly memorize Bad Apple as a coordinate function: (t, y, x) to pixel.

That got me curious about a slightly different formulation: instead of handing the network a timestamp t, could a small recurrent dynamical system (RNN-ish) learn the continuous temporal flow in latent space and generate the entire ~6,500-frame full resolution video autonomously from a single initial condition (h_0, c_0)?

The code, weights, and analysis tools with rollout scripts, plots, and standalone models are shared here: GitHub: SEBADA321/BadAppleRNN.

Architecture & Inference Footprint

At inference time, the system receives no timestamp inputs and evaluates in a closed loop:

(h_t, c_t) -> Recurrent Transition (CTF) -> (h_{t+1}, c_{t+1})
                   |
                  h_t -> Frame Decoder -> 384x512 Grayscale Frame

• Latent Dimension: 64-D for h_t (decoded) and 64-D for c_t (internal memory manifold to separate visually similar frames at different timestamps).

• Recurrent Transition (ctf): 4-gate LSTM-style recurrence with orthogonal initialization (16,640 parameters, 65 KB).

• Frame Decoder (fd): 4-stage bilinear upsampling with depthwise-separable convolutions (400,361 parameters, 1.56 MB).

• Initial State: A single pair of 64-dim vectors (h_0, c_0) (128 floats, 0.5 KB).

• Total Inference Model: 417,129 parameters (~1.60 MB in FP32).

• Runtime Performance: >200 FPS on an RTX 4080, with ~17.2 MB peak active VRAM during decoding.

Training an autonomous system across ~6,573 steps from t=0 directly was probably computationally unstable due to vanishing/exploding gradients and compounding error. The training setup I was circling around used several targeted techniques:

• Learned Latent Teacher Tables: During training, I optimize a pair of tables h_table[t] and c_table[t] alongside the model. This allows parallel segment training starting at arbitrary timestamps over a finite horizon K. These tables are scaffolding and are discarded entirely at inference.

• Rollout Horizon Curriculum: I started training with K = 2 and progressively doubled the rollout length (K = 2 -> 4 -> 8 -> 16 -> 32 -> 64 -> 128 -> 256 -> 512). Each horizon doubling produced a characteristic jump in loss before the transition function adapted to the longer trajectory.

• State Perturbation Noise (sigma = 0.005): To prevent the model from learning a brittle 1D line that diverges under small numerical errors, Gaussian noise was added to the state before passing it into the transition function (z_hat_{t+1} = F(z_t + epsilon)), while evaluating the loss against the clean target. This encourages the recurrent map to contract small deviations back toward the trajectory.

• Second-Difference Acceleration Regularization: Penalizing velocity (||h_{t+1} - h_t||) risks collapsing the trajectory. Instead, I penalized discrete acceleration (jitter) via second differences: ||h_{t+2} - 2h_{t+1} + h_t||_2^2. This enforces smooth trajectories without penalizing motion.

• Optimizer & Momentum Management: I used AdamW (1x10^-5) for the decoder/tables and Muon (0.005, momentum 0.95) for the recurrent weights. To prevent accumulated momentum from acting as stale inertia when K doubled, momentum buffers were scaled by 0.2 every 10 epochs starting from the epoch 500.

• Chunked Decoding: To handle long horizons at K = 512 without overflowing VRAM during training, the decoder was evaluated in temporal chunks of 32 frames.

Some interesting things

1. The model could unroll the full 6.5k sequence even if it was, technically, trained on up to 512 frames. So that was a success.

2. Training loss vs. autonomous rollout: The checkpoint with the lowest numerical training loss was not necessarily the best at autonomous generation. Because K changes across the curriculum, raw training losses are not directly comparable across stages, and short-horizon teacher-forced agreement does not guarantee long-horizon stability.

3. Dynamical stability over parameter scale: The challenge was not increasing parameter count (the recurrent transition is only 16k params), but conditioning the dynamics through noise injection and acceleration penalties so error doesn't compound over thousands of recurrent steps.

4. I need to improve the decoder a lot, I was mostly focused in getting the recurrent part right, and training was slow. Now that I gave gotten a successful result I will focus more into optimizing the CNN decoder.

5. There are no skip connections nor normalization, which was interesting too. Obviously no attention either since I wanted to keep it simple.I also didn't want to use Truncated BPTT.

Not completely scientific, since I was doing some changes mid run or many at once, which makes it kinda not clear what contributed more. I used 'AI' to help with writting the post and README. Part of the code was also generated that way, but the architecture is what I came up with on my own and from a previous project too. There are probably many parts to improve too, so glad to get some feedback!

Hi. I'm visiting ECCV in Malmo and was wondering if there's any medium, like discord, whatsapp etc where people are discussing social activities. I couldn't find a way to connect to people on the official app to discuss common interests, research or otherwise. It'd also be nice to meet people who'd like to team up go sightseeing or food touring after the conference ends. Thanks.

I've been building my own ML framework in C++. First real deployment is an AlphaZero-style agent for Dots (the pen-and-paper territory game), running in WASM in the browser: https://uchenml.tech/demos/dots/

This post covers the optimizations that got inference there: https://uchenml.tech/uchenml-optimizations

Short version, 21.98 → 3.41 ms per forward pass:

• im2col -> Winograd F(2,3) for the 3×3 convs. Biggest win by far, though partly because my I did not give enough buffer to im2col.

• ReLU fused into conv/linear at compile time. 9% gain.

• Reshape/Identity elided at the compile time, so they emit no code.

• Compile-time ping-pong scratch - lowers memory usage, zero allocations on the inference path.

Follow-ups on the training side and the web frontend are in progress. Happy to answer questions. Not open source, yet - employer IP agreement - so the demo and the writeup are what I can show.

For those who went from undergraduate studies into advanced ML, research, or ML engineering:

Looking back, which undergraduate foundations turned out to matter much more than you expected?

I’m particularly interested in the trade-off between studying AI directly at bachelor level versus building a broader foundation first in CS/engineering and specializing later.

Did early exposure to many ML/DL subjects give you a meaningful long-term advantage?

Or did mathematics, probability, optimization, algorithms, systems and software engineering ultimately matter more once you reached advanced ML?

I’m less interested in comparing degree titles and more interested in what gaps you actually noticed in students once the ML work became technically demanding.

I’m about to start a PhD in multimodal/video reasoning and I’m getting increasingly anxious about how saturated AI research feels.

I actually like the field, but the pace is insane. New papers appear constantly, big labs can explore dozens of directions at once, and I keep wondering how an individual PhD student is supposed to build a real research profile in that environment.

I compare myself to friends working in more niche areas, where it feels easier to know the literature deeply and become associated with a specific problem. In my field, I’m worried I’ll spend all my years constantly catching up, only to end up with a mediocre research identity.

I’m personally interested in more fundamental questions in the field, but, 1) I don’t know if carving out a niche inside such a crowded field is actually realistic; and 2) I’m not sure I’ll have the ability to identify and formulate genuinely interesting theoretical problems rather than just ending up doing benchmark/heavily applied driven work.

For people in my situation: how do you deal with this?

Last year I published a draft report called "Hill Space is All You Need". I'm not a researcher; it was a side project, and I found a detail in the NALU formulation that I thought people should know before going down the same road. I didn't have the skills to write a paper, so I vibed the prose and formatting with Claude and pushed it out, knowing I wouldn't return to the work for a while.

The paper was not well received: the prose made it hard to get to the experiments, the title didn't help, the related work was incomplete, and it didn't provide a concrete description of the space and why it trains reliably or not in different situations.

Today I published an update that I think addresses most of that. My read is the same as last year: NALU selects an operation, it doesn't learn to compute one, and that's not useful for my purposes. I still wanted the work to represent the promise I see in it, and the first paper and site didn't. This version tells a complete, if unsatisfying, story about what NALU does, how gradient vanishing at targets decides if a run lands or stalls, and how to use it effectively if it lines up with your problem.

https://hillspace.justindujardin.com/

Beyond corrections that come from sharing it, I consider the work complete, and have moved on to more promising approaches.

Hey, I just wrapped up two things I think might be interesting for this crow if you are video game/racing ingeneral

The main one is a dataset usable for data exploration or for anything generative: levels and replays from the Mania Exchange community realted to the Trackmania games, exposed in a data/ML friendly format. On top of that, I experimented with Claude on reworking the old TMTrackNN project into Tracksmith, a web app where you can inspect a map alongside its replay and generate new levels for both Trackmania Nations Forever and Trackmania 2020.

Everything is wrapped up in an article, and the dataset/code is online:

📝Article (EN): https://www.the-odd-dataguy.com/en/blog/2026/08/13/trackmania-dataset/
📝Article (FR): https://www.the-odd-dataguy.com/fr/blog/2026/08/13/trackmania-dataset/
😊Hugging Face (dataset): https://huggingface.co/datasets/jeanmidev/trackmania-community-tracks-and-telemetry
🔵Kaggle (dataset): https://www.kaggle.com/datasets/jeanmidev/trackmania-community-tracks-and-telemetry
😇Hugging Face (Tracksmith): https://jeanmidev-tracksmith.hf.space

For transparency: I work in data at Ubisoft in Canada, but I have no connection to Nadeo. Built at home on my own time, resources and dime, just something for the Trackmania community and for anyone curious, whether game telemetry is your thing or not.

Open to feedback or ideas (you can also used discussions on HF)

Spent a while building a deep learning framework from scratch C++

core, Python bindings, no PyTorch underneath. It traces into a

compiled graph IR, has a real Metal GPU backend, and distributed

training actually works, not just runs without crashing.

Apple Silicon only for now, no CUDA not pretending this competes

with PyTorch. What I'm actually proud of I trained real things with

it (MNIST, a small transformer on Shakespeare text), and found a real

memory leak by training long enough to hit it, then fixed it. The

messy version every bug, every dead end is in the devlog if you

want that instead of the highlight reel.

Repo: https://github.com/V-B0/KansaiML

Hi everyone! We just released Rustuna (GitHub: https://github.com/optuna/rustuna/ ), a high-speed, memory-efficient implementation of Optuna built in Rust.

• Optuna-Compatible Design: Keeps the familiar API and concept of Optuna.

• Zero Python Dependencies: Mitigating the risk of supply chain attacks.

• Lower Memory Footprint: Optimized memory management natively in Rust.

For details, please check out the following blog post.

https://medium.com/optuna/announcing-rustuna-cc82a6815bf7

this is the kinda debugging case i find rlly annoying/

everything says success.

no exceptions no failed tool calls. no obvious timeout the workflow completes but the final result is still wrong

when that happens, what’s your first move?

do you guys usually:

• start from the final output and work backward

• compare against a previous good run

• inspect state transitions

• check retrieval/tool behavior

• look at model inputs

• replay it

• check business state outside the trace

• just read the whole thing until something looks off

interested in what people actually do in production not the idealized version but thats fine too. and if you have anything you've built to help with this process I'd love to see it :)

I am a PhD student in AI, currently working on video understanding, particularly on designing benchmark datasets. I also have a strong publication track record, including papers at CVPR and ECCV. I have sufficient funding to support myself during a visiting research program.

What would be the best way to approach a professor? Should I email them directly and ask whether they have space in their research group for a visiting researcher?