Hi everyone! I recently decided to dive into animatronics and started building an open-source robotic desk lamp inspired by expressive animated lamps from Pixar. This is still a very early mechanical prototype. Right now only the base and the first joint move, and I'm designing the rest of the arm. I'm looking for advice on one of the biggest design challenges: how would you route the cables through the moving joints while keeping them hidden and minimizing stress on them? If you've built articulated robots or mechanisms before, I'd really appreciate any examples, photos, or resources. I'd also love to hear your ideas for useful features. My current plan is to eventually add a depth camera so the lamp can understand its surroundings and interact with people. As a fun long-term challenge, I'd even like to see if I can teach it to jump or move around on its own. Any suggestions or criticism are very welcome! submitted by /u/Ok_Stress3654 [link] [Kommentare]
What it is Talos-XII is a CLI simulator for the gacha system in Arknights: Endfield. Rather than sampling from a static probability table, it trains a small set of neural nets to model environment uncertainty and pull-decision policy, then uses them to answer questions a static table can’t easily express — e.g. “as a F2P player, what’s my probability of getting the rate-up unit on free currency alone?” or “given my current pity count, should I keep pulling or save for the next banner?” Models (trained on first run, ~30-45s, then cached to disk) • EnvNet — small MLP fitting an environment noise/bias distribution, sampled per simulation • Luck Optimizer — neural optimizer over a 32-dim engineered feature vector (pity progress, streaks, interaction terms) • Dueling DQN — discrete pull/wait decision • PPO actor-critic — with an MLA (latent-attention) transformer for continuous strategy Everything underneath is hand-written, no external ML framework: • Custom autograd engine (matmul, conv2d, pooling, norms, gradient-checked backward passes) • Runtime SIMD dispatch: scalar → AVX2 → AVX2+FMA → AVX-512, NEON on ARM64 • Rayon-parallelized sims (~10k+/sec on my laptop) • BF16 inference caches • Optional PyO3 bridge (import talos_xii as tx) for writing training scripts without NumPy/PyTorch • 142 tests, CI on Linux/Windows/macOS with ARM64 cross-compile, single static binary, MIT The part I’m not confident about There’s a component I call ACHF (Adaptive Cache-aware Hyper-Connections): it blends a dense path with a pruned sparse path via a gradient-sensitive gate, adds a manifold (Sinkhorn) weight projection, and switches between cached/sparse/dense execution paths based on measured latency. Loosely inspired by manifold-constrained hyper-connections, but aimed at a different regime — compact RL policies running on CPU inside a single binary, not large-scale training. I don’t yet know if the speed/accuracy tradeoff holds up outside my own machine. I’m treating it as an open experiment, not a result. Where I’d like help I only have access to my own hardware, so my benchmark coverage is thin. There’s an automated benchmark suite in the repo that reports mean ± std with 95% CIs, per-path latency distributions (p50/p90/p99), training curves, and raw CSVs — instructions are in the README. If anyone’s willing to run it on a different CPU (AVX-512, ARM NEON) or GPU setup, I’d genuinely appreciate the data — negative results (ACHF not helping on your hardware) are just as useful to me as positive ones. Repo: github.com/zayokami/Talos-XII Solo project, built to learn Rust + ML fundamentals from scratch. Happy to answer questions about any of the implementation details. submitted by /u/zay0kami [link] [Kommentare]
I'm an 18-year-old independent student from Tunisia. I built and I'm leading an open, from-scratch machine-translation pipeline and parallel corpus for Tunisian Darija. Sharing it for feedback. Why: Tunisian Darija, written in Arabizi (Latin letters + numerals like 3/7/9/5 for Arabic phonemes), has almost no open NLP resources. Existing Arabic tools route it through MSA and mishandle the orthography. To the best of my knowledge there was no open parallel corpus or from-scratch baseline for it. What I built (all open): - Arabizi-aware SentencePiece BPE tokenizer (3/7/9/5 as protected symbols), shared 16k vocab. - ~15.6M-param encoder–decoder Transformer, from scratch (no pretrained LM): transfer-learned from cleaned Moroccan Darija, then fine-tuned on hand-crafted Tunisian pairs. - Full cleaning / training / eval pipeline. Honest results & limitations: v1 BLEU is 3.89 on a small locked test set low, and I'll be upfront about it. The corpus is ~553 hand-crafted pairs, so data is the bottleneck, not architecture. I treat 3.89 as a first honest baseline to beat as the corpus grows. Where I'm taking it: I'm expanding this into a larger, ethically-collected Darija corpus that I curate and validate consent-documented field collection, every pair provenance-tagged. I'm looking for contributors to help grow it, with every contribution reviewed to keep quality and consent standards. Looking for: technical feedback/critique, and anyone interested in contributing data or collaborating on low-resource / dialectal Arabic MT. Links: github repo: https://github.com/Dhiadev-tn/darija-translator Hugging faces dataset: https://huggingface.co/datasets/Dhiadev-tn/tunisian-darija-english hugging faces model: https://huggingface.co/Dhiadev-tn/darija-translator submitted by /u/Dhiadev-tn [link] [Kommentare]
I've been trying to come up with a solution for keeping extremely long ai sessions coherent. Sometimes there is too much substance to risk compaction. With so much buzz around diffusion going on it got me thinking, what if we treat the context like a progressive render, blurry>sharp. The practical way to make text "blurry" is compression. This is a "diffusion inspired" system which borrows the coarse-to-fine process, not the formal math. It uses semantic compression so the overall structure of the session stays intact. Read the compressed version first to build an outline. Then read progressively less compressed slices until you're reading small verbatim chunks that give full detail. So you're basically using compression as noise on the input side, then progressively building an output. Each slice is compressed to fit within the context window, so the model only ever needs to read the current slice+input+current output. Tell the model what pass it's on, so it knows whether to write an outline or add detail. The thing I'm actually trying to preserve is what you'd call "non-local information". Think of it as stuff that surfaces when looking at the whole session & doesn't survive fragmented retrieval. Retrieval misses it, compaction deletes it. Both miss what only exists in a holistic view. Here is a visual demonstration to get a general idea of the workflow. https://dev-boz.github.io/diffusive-semantic-compression/demo/architecture-demo.html There is substantial overlap with lots of prior art, Recursive Language Models is one of the closest (source and output on disk, process recursively). I wrote most of this before I found RLM and nearly gave up before realising there was still a small part that was novel. As far as I can tell there's no exact match for this particular implementation. Please let me know if I've missed one. The difference to regular masked diffusion is in changing the length of the input rather than just masking. What seems to be new ground is using compression as noise and a position-aware process. I've done some basic testing. Mainly to see if it was at all viable. Just some basic tests using small models like Qwen2.5 7B. The untrained models show that they can do each part (outline, refine, add detail) but they struggle with the full end-to-end process. There 's occasional end-to-end success, but it's nowhere near reliable. On untrained models it also hasn't yet beaten a cheap dense read of the same document. The main bet is whether position-aware training changes that, I haven't been able to test that yet. I've published all the pre-registered failures, parser bugs I found etc. Another note: the goal is preserving structure and nuance, but the tests so far measure planted facts and split-up numeric composition. Mainly because the experiments needed answers you can actually score. The nuance evaluation is being designed but isn't ready yet. The next step is a small model fine tune to test if position aware training can help. If you have the time to look at the idea, it really needs a prior art check from anyone who knows the diffusion-LM/long-context space. And if anyone wanted to help expand the idea or contribute with compute or collaboration for the fine-tune please do. Here is the repo for the proposal. Links to testing repo and prior art inside. https://github.com/dev-boz/diffusive-semantic-compression submitted by /u/Bravo_Oscar_Zulu [link] [Kommentare]
Researchers designed an origami-inspired robotic arm that allows surgeons to perform precise subretinal injections by folding lightweight plastic into a structure strong enough to deliver exact surgical force without any heavy metal components. Weighing under 18 grams and precise to 12 micrometers, the device has already been used successfully in real in vivo eye surgery for cell and gene therapy delivery. This breakthrough could replace bulky kilogram-heavy surgical robots with lightweight origami-based tools, transforming how delicate procedures are performed in crowded operating rooms. Published in npj Robotics, 2026. submitted by /u/Similar_Suit_3709 [link] [Kommentare]
Hi a I'm submitting my first arXiv paper in cs.AI. arXiv requires first-time submitter(s) to have an endorser. Is anyone here active in cs.ai or similar such as emerging tech, agents, etc. and willing to take a 30-second look at the abstract and click endorse if it's a fit? I can DM the abstract and section headings. I greatly appreciate you taking the time! submitted by /u/rredditscum [link] [Kommentare]
Currently live streaming a remote controlled session of two robot arms playing chess! You can control the arms at https://www.armcade.tv submitted by /u/earthtojek [link] [Kommentare]
I'm on my semester break and using the time to learn robotics. I just got my wheeled robot running in Gazebo!! what should I explore or build next? Looking for ideas, challenges, or a roadmap. submitted by /u/AxBodiSpray [link] [Kommentare]
I had a first go, putting together some of our friends in the space + a bit of research. Who’s missing? Feel free to tag your venture in the comments. submitted by /u/Erlapso [link] [Kommentare]
Stress testing my homemade 6dof arm! Total BOM of about $200, uses 4x STS3250 servos (50kg torque) and 3x STS3215 servos (30kg torque). submitted by /u/earthtojek [link] [Kommentare]
I recently started a Telegram community called The Daily Commit. The goal is simple: stay consistent and hold each other accountable. What we do: 🧠 Share what we learned every day. ❓ Discuss ML, DL & DSA doubts. 📚 Share quality resources. 🚀 Build projects together. 💪 Stay consistent through daily accountability. Who can join? I'm currently looking for people who already have some exposure to Machine Learning or Deep Learning. You don't need to be an expert—if you've learned the basics (e.g., linear/logistic regression, neural networks, or have built a few ML projects), you're welcome. The reason is to keep discussions technical and valuable for everyone. If you're genuinely interested, send me a DM with your little intro, and I'll add you. submitted by /u/pyaaz_ [link] [Kommentare]
Hi all, I’m working on a research project exploring how stateless LLM-based chatbots handle long conversations and whether important earlier information is still reliably retained over time. My idea is to: Run a chatbot using an LLM API without any external memory system Introduce key facts early in a long conversation Continue with many unrelated messages (hundreds of turns) Later test whether the model can still correctly recall those facts at different intervals I’m planning to measure recall accuracy and how it changes as the conversation grows. Before I go deeper, I’d really appreciate feedback on: Is this a valid way to evaluate long-context memory limits? Are there better benchmarks or methods already used for this? What metrics would make this more rigorous and convincing? Any suggestions or criticism are welcome. I’m trying to make the evaluation as solid as possible before building it out. Thanks! submitted by /u/QuietAccountant4237 [link] [Kommentare]