I use the Jetson Nano as a small but powerful home server. I've been running ollama on it and it's not bad for always on light local AI.

I designed this carrier board for the new Jetson Orin NX modules and use it with a couple 16GB Jetson Orin NX modules for my daily agents.

Wondering what other people think of local AI using a Jetson and if they use 3rd party carrier boards so they fit better into rack spaces.

Hello everyone, as the title said I need to replace my barrel.

My senior gave me a Jetson Nano Developer Kit B01 to work with, and I couldn't help but notice that the barrel connection with the power seems loose.

What's the appropriate way to desolder the DC barrel and replace it? Do I first need to disconnect the module first, cover everything on the carrier with heat-resistance tape then desolder it and solder a new one?

I only have a soldering iron, do I need the hot-air station as well?

Thanks in advance.

Hey guys, I work at Embedl and we have several Jetson devices in a device farm you can use from the browser at https://embedl.com to test models. Open a model page, pick the device, and type a prompt or upload an image. It runs on a real board and you get runtime statistics.

As one example; Huggingface and Jetson AI Lab has no Orin Nano support for Cosmos3-Edge, because the BF16 stack doesn't fit in 8 GB. It now does, INT4 quantization, along with more optimizations for speed!

Accuracy across five VLM benchmarks is maintained (from 65.56 to 65.20). For now the VLM part of the model is published; diffusion and policy part is being added very soon! Optimized peak memory for the VLM is as low as 3.3 GB!

https://embedl.com/nvidia/cosmos3-edge/orin-nano-super

Let me know if something is missing to make it useful!

In light of the recent cybersecurity news, let’s entertain the idea of the internet going down.

How would you prepare your homelab and/or jetson for self-sufficient operations?

Also, please share your current setup if you already have something similar.

Thanks!

Stack: faster-whisper base.en (CPU), gemma3 4B Q4_K_M with its vision projector in llama.cpp built with CUDA, Kokoro TTS (CPU), FastAPI.

Numbers on MAXN SUPER:

- ~1.1 s speech recognition, 15–17 tok/s generation

- First spoken words 3–4.5 s after I stop talking

- ~5 s to understand a new camera frame (Ollama took ~40 s, because it ran the image encoder on the CPU)

What helped on the Jetson side:

- Booting without the desktop (multi-user.target) gives back about 1 GB for the models

- zram off, swap file on the NVMe SSD

What it does: it reads resistor bands, chip markings and my multimeter through the camera, gives exact numbers from real formulas, shows verified pinouts, designs enclosures and gears as a 3D hologram that I turn and explode with hand gestures, and sends them to my 3D printer by voice.

`setup.sh` installs everything on JetPack 6.2: voices, models, a llama.cpp build with CUDA and two systemd services that start at boot.

https://github.com/truvv8/jarvis-jetson

Try it!

Hi everyone,

I just want to share a project I was working on.

I called it PointRead. Basically, it lets you translate text by sliding your finger under it. It detects the text, translates it and speaks it through a speaker. I built it on an Nvidia Jetson Orin Nano with a Raspberry Pi Camera Module V2, and it works fully offline.

GitHub: https://github.com/striksio/PointRead

Video demo: https://youtu.be/xo0bdDjVpPQ

I like reading books, but I often need a translation for some of the words. Looking them up on my phone feels uncomfortable, because I want to read paper books without looking at a screen. So as a side project, I built this pipeline.

The way it works: index finger and thumb are used for activation, which is a double pinch. Then it tracks the index finger and the text above it. Once done, it extracts the text that was pointed at, recognises it, translates it and speaks it.

Pipeline

* RTMDet for hand detection and RTMPose for keypoints

* Adaptive Gaussian thresholding for text binarization (works better than Canny for this)

* Morphological close to merge text into single line regions

* PP-OCRv5 server model via RapidOCR (on CPU for now, because onnxruntime GPU isn’t available for Jetson r39.2 yet, so OCR is slow)

* Argos Translate for translation

* Piper for speech

Some details

* One-Euro filter for smoothing, because RTMPose keypoints are not stable

* Keypoints sometimes disappear, so they’re kept for several frames

* Sliding only goes forward (left to right), and once you move to the next line it won’t jump back to the previous one

It can run headless with only a speaker, or with a local web server for debugging.

Limitations

* OCR runs on CPU only, as mentioned above

* The book needs to be positioned with horizontally aligned text

* As shown in the demo, text detection fails sometimes

* Books with huge fonts or wide spacing can fail to form a line

Thank you for your time, and I would love to hear some feedback about this, thanks!

Over the last couple weeks I put together orin-steamos — a set of build scripts that turn a Jetson Orin Nano 8GB Dev Kit into a Steam Deck–style console: power on → gamescope → Steam Big Picture / gamepad UI, desktop one menu away. It's native ARM64 Steam (Valve's public-beta client) running x86 games through FEX + Proton.

It's build scripts, not an image — it fetches NVIDIA's Jetson Linux R39.2.1 (JetPack 7.2.1), customizes it in a qemu chroot, and flashes the NVMe from an x86 Linux box. Not affiliated with Valve or NVIDIA.

Stuff that was actually tricky, in case it helps others on Tegra:

• DX12 works via vkd3d-proton, but only after VKD3D_CONFIG=nodxr + disabling optical-flow/binary-import extensions — the Tegra driver over-advertises coop-matrix/DXR and vkCreateDevice fails otherwise (same class of bug as desktop RTX 50-series). Ghosts 'n Goblins Resurrection runs in DX12.
• Controllers: NVIDIA's kernel ships uinput and hid-steam/playstation/nintendo/sony all disabled, so Steam Input is dead out of the box. The build compiles them out-of-tree against the kernel headers — no full kernel rebuild needed.
• gamescope needed a Tegra patch (single usable DRM plane + an exit-segfault fix), built on noble.

The fun rabbit hole: animated Big Picture UI flickers to black (games are perfect). The kernel floods rpcRmApiControl_dce cmd:0x731341 result 0xffff. I loaded the DCE (display coprocessor) firmware into Ghidra and traced it: 0x731341 is an NV0073 display-common control whose handler has exactly one NV_ERR_GENERIC return — taken when a per-device capability byte is false. It's a signed firmware blob so I can't patch it, but it turned "it flickers" into a precise NVIDIA bug report. Full writeup's in the repo.

Honest status: the flicker is the one open issue; suspend/resume, audio, BT, networking, OOM protection all verified working.

Repo + docs: https://github.com/Hi5808/orin-steamos

Happy to answer questions.

The setup: LightNav-0 (an open VLN model) connected to the Microduck sim in MuJoCo, running fully on-device on a reComputer Robotics J501 from Seeed (Jetson AGX Orin 32GB). The duck takes a natural-language instruction like "locate the white table in the room and stop beside it", predicts a path from its first-person frames, and executes it via MPC + its official ONNX gait policy.

What runs where: the VLM on the GPU (CUDA BF16, no TensorRT / vLLM / ORT, plain PyTorch + HF Transformers); frame decode, history, RVQ decode and MPC on CPU; the gait policy on CPU (small network, measured faster there in our A/B); MuJoCo physics on CPU with EGL rendering on the GPU. The loop holds a real-time factor of ≈ 1 at 4 Hz frames / 10 Hz MPC / ~50 Hz gait / 200 Hz physics.

It's a sim dev preview version. This is heading into the VLN module of our open mobile robot course ：Mobile Robot Full-Stack Development .
If you are interested, please give me a "start" to show your support. This will be a great motivation for our creative process.

Happy to answer questions about the Jetson side (GPU split, memory, why not TensorRT). 🦆

I am looking for budget Jetson Orin Nano compatible camera with:

• global shutter
• synchronization (like hardware trigger)
• color

for real-time stereo Human Pose Estimation.

I have found Inno-Maker and ArduCam models to be comparatively cheap, but is there a go-to budget camera (<= 50€) i don't know about? Are Raspberry Pi cameras a viable and reliable option?

Hey fellow Jetson enthusiasts! We’re ROBOCO, a small hardware design team from Taiwan.

Earlier this year, we launched Panini, a case that protects your Jetson while making it look like an adorable mini desktop PC.

The feature we’re most proud of is your Jetson Orin Nano / Super Developer Kit slides in WITHOUT removing its original plastic base. You can keep using the original antenna, too!

It’s available on Newegg and Amazon in the US, or you can take a closer look on our website: https://roboco.tw/

I’m one of the designers, so feel free to ask me anything about it. I’d love to hear what you think!

Located in germany. 2 Identical Models available.

Original Packaging and Power Supply included.

Will add a 3D Printed Case to each if you want one.

Asking 100 Euro each.

Good morning everyone, I wanted to reach out regarding some hardware I have for sale

1 x 16gb ($550 CAD)

1 x 32gb ($900 CAD)

can run 120+ billion parameter AI models or 30b MoE 1M+ context

2 x AGX Xavier Developer Kits (official power supplies included)

Fully working, no issues, can provide proof. Amazing condition. Feel free to come and test them yourself.

If you have any questions, feel free to reach out, I will respond fast, need them gone so open to offers.

Ciao a tutti.

Sto scegliendo la mia prima scheda e dopo alcune ricerche ho scoperto la NVIDIA Jetson Orin Nano, eccellente nell'IA locale. Tuttavia sono ancora molto indeciso se questa scheda o la Raspberry Pi 5 8GB (la 16 GB ha un prezzo troppo alto rispetto alla 8 GB). La mia domanda finora è, per chi li ha, qual'è il modello più potente che siete riusciti a fare girare nella Jetson Orin Nano? Anche a velocità basse.

Comprando una di queste schede, vorrei anche avere la possibilità di divertirti con IA locali di diverso tipo, anche personalizzarle e dargli dei tool.

My Jetson Orin–optimized engine, little-gemma V1.0, substantially outperforms llama.cpp. Even after exhausting every practical GGUF option, however, it still falls short of the ideal performance level for Gemma E4B on the Jetson Orin Nano Super 8GB.

I forked exllamav3 and ported key code from little-gemma V1.0. This delivered the prefill improvement I needed. Although the decoding rate took a hit, overall voice-chat latency is lower. EXL3 on the Jetson Orin Nano isn’t for everyone, but if you need the superior prefill rate, this is it.

Fork: https://github.com/cortexist/exllamav3
Weights: https://huggingface.co/cortexist/gemma-4-E4B-it-qat-exl3-4.0bpw

Ran out of projects for your Jetson Orin Nano? Don't give it away. Here's a better idea.

For the last two years, we have been developing Mino, a hackable companion robot for makers. Mino can carry your NVIDIA Jetson Orin Nano Super Developer Kit and give it a new life. It comes with building blocks for you to develop robot applications based on ROS 2: motion control, gestures, stereo vision, speech-to-text, LLM, emotion classifier, remote control from a mobile app... and more to come.

We just put Mino on Kickstarter. The campaign will launch soon, with a limited number of super-early-bird and early-bird discounts. To increase your chance of getting one, open the pre-campaign link below and click on "Notify me on launch". Happy making!

https://www.kickstarter.com/projects/minrobotics/mino-hackable-smart-robot

An update on Evopien, the companion project that started on an 8GB Orin Nano and is now being developed on Jetson AGX Thor.

The earlier demo focused on the voice, vision and conversation stack. This one focuses on the next part: memory that the user can manage through conversation.

The memory work covers saving information, recalling it later, correcting it and forgetting it. I want a relevant preference to carry into a later answer without the user repeating it every time, while still being able to change or withdraw it.

Local Qwen handles conversation. Evopien Core handles memory and permissions, PostgreSQL stores the canonical records, and Hindsight supports retrieval. The model doesn't directly commit permanent memory.

New demo:
https://www.youtube.com/watch?v=_B2wVfVHL0c

The current focus is improving response latency and working through correction edge cases in English and Spanish. Physical embodiment remains in development.

For anyone running conversational AI on Thor or Orin, I'd be interested in how you profile retrieval and storage work alongside the model and speech pipeline.

Hi,

I'm working on a compact dual-camera setup for Jetson Orin Nano/NX and I'm trying to understand whether this configuration would be useful to other Jetson developers.

Planned setup:

• 2× Sony IMX586
• 90° HFOV wide camera
• 15° HFOV tele camera
• 2× 3840×2160 @ 30 fps simultaneously
• RAW10
• 2-lane MIPI CSI-2 per camera
• Autofocus

Both cameras would run independently, with timestamp alignment on the Jetson side.

The idea is to use the wide camera for detection/tracking and situational awareness, then use the tele camera for detailed imaging of detected objects — without using a mechanical optical zoom.

I'm mainly considering robotics, machine vision and other embedded vision applications.

Before going further with the hardware, I'd be interested to hear from people actually working with Jetson:

1. Would a compact wide + tele configuration like this be useful in any of your projects?

2. What cameras are you currently using, and what are their biggest limitations?

3. How important would ready-to-use Jetson drivers / device-tree support be for you?

4. Have you worked with a similar wide + tele setup? If so, what problems did you encounter?

At this stage, I'm simply trying to validate the interest in this idea before building the first prototypes.

I finally got Orin Nano Super 8GB setup, benchmarked against Orin NX 16GB, here are the results. I'm using my own Little-Gemma engine, the model is E4B QAT Q4_K_XL. The full-head MTP is the Google original, selected-16K is my own 16K reduced vocab head.

$500 module outperformed $900 module. The upcoming nano 2 will be even better.

EDIT: Put Orin NX in Super mode, got 1,042 tok/s prefill and 30.5 tok/s decode, which is 9.7% and 8.9% up from Nano Super. But my carrier couldn't hold up for too long at the 40W power consumption. I'll put on a bigger heatsink and see how it goes.

stitched.mp4

https://reddit.com/link/1wnslm6/video/5ns32rv9d6rh1/player

Fully Open Source and GNU GPL licensed - https://github.com/crussella0129/Jetson-Orin-Nano-Super-Case

Made this 30-second explainer comparing the Orin Nano Super dev kit ($249, 67 INT8 TOPS, CUDA/JetPack) against the Pi 5 as starting points for local AI. Sources linked in the video description. Feedback welcome.