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

As it stands, my AI ambitions have outgrow these two (never got to 3rd one that's new in box one)

The original Nano (4GB) has a self made fan to help cool it and comes with a 64GB micro SD card.

$150 +shipping

The used Jetson Orin (8GB), has a Waveshar sound card that also has built in microphones, WiFi and Bluetooth extender antenna, and a 64GB micro SD card.

$300 +shipping

The new Jetson Orin (8GB) comes complete in box, and a 64GB micro SD card.

$250 +shipping - Sold to u/crx880

Prices are in USD.

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.

I was having fun with my jetson nano and open sourced a repo to train a sudoku solver from scratch on it (looped MLP-mixer, inspired by TRMs).

Here it is https://github.com/romainzimmer/discrete-reasoning if you want to play with it!

Most model leaderboards assume a server with powerful GPUs to run models that people daily use.

However, my smolbenchmark is the other column: models that fit in 8GB, ranked by:

• decode speed,
• tokens per joule, and
• heat,

and all of this on your OWN hardware ranging from:

• tablets
• phones
• macs
• jetsons
• raspberry pis

Currently, 13 families on the chart right now, ~1000 configs for the Jetson nano Orin Super 8GB. One device is live measuring:

• tok/s
• tok/J
• ITL
• latency
• power metrics
• thermals and battery

Models that are small enough to actually fit on a device that you own. All the performance benchmarking I did, will be released here for anyone to look at and decide what exact model they would wanna use on their choice of hardware.

Well currently, the Pi, phones, and Mac minis still in the oven, cooking and not filled in yet, but will soon be filled in!

You will now you know which model is BEST for your own hardware with all the raw data available and details reports available to you

https://yuvrajsingh-mist.github.io/smolbenchmark/

(still in heavy development; would love to hear feedback/suggestions on what can be improved!)

I’m using a Jetson Nano as a small always-on home server. I run Home Assistant, Zigbee2MQTT, and my other services entirely in Docker.

Every ~2–3 days, the system becomes partially unresponsive. I usually notice because my Home Assistant lights stop working from my phone and HomeKit also stops responding.

The weird part is that the Jetson doesn’t appear to completely disappear from the network.

When it’s in this state:
ping 192.168.4.33 works normally with ~3–4 ms latency and 0% packet loss
TCP port 22 is reachable
TCP port 8123 (Home Assistant) is reachable
TCP port 8080 (Zigbee2MQTT) is reachable
But SSH never gets past the initial connection
HA’s web interface doesn’t respond
Zigbee2MQTT’s web interface doesn’t respond
HomeKit stops working
I have to physically unplug/replug the Jetson to recover it

For example, ssh -vvv gets to:
debug1: Connecting to 192.168.4.33 [192.168.4.33] port 22.
debug1: Connection established.
...
debug1: Local version string SSH-2.0-OpenSSH_8.5

and then hangs. It never receives the remote SSH version string.

Interestingly, the application ports accept TCP connections, but don’t actually respond. For example:
curl -v --max-time 5 http://192.168.4.33:8123/
successfully connects, sends the HTTP GET, and then receives absolutely nothing until timing out after 5 seconds.
The same happens with port 8080.

So it seems like the Jetson/network stack is partially alive, but processes aren’t actually servicing connections.

Everything is running in Docker, so I’m wondering if this could be:
storage/SD-card I/O problems
kernel/driver lockup
memory exhaustion
Docker/containerd issue
power instability
filesystem problems
some Jetson-specific hardware/driver

Hi guys, I am a senior FPGA Engineer. Recently I started to work with jetson orin products. It was pretty easy for me to work on standalone FPGA project where i just sample signals and make the video pipeline work.

But on jetson i can’t decide which way is the best for capturing video images, processing and encoding etc.

Do you guys follow nvidia api samples? Or do you have any sources to follow?

JupyterLab with LIVE Jetson metrics

About 10 months ago I posted here about something we were building because of a problem we kept running into ourselves.

We were buying Jetson boards before we really knew what our workload needed.

Nano turned out to be underpowered, so we moved up to an Orin. Then came the next question: do we need an Orin NX, an AGX Orin, or something even bigger? And before you even got to the model, you've spent time flashing JetPack, sorting dependencies, CUDA versions, etc.

So we built remote access to physical Jetson boards.

While initially people trickled in to check it out occasionally , recent experimentations have blown us about what experiments users are running in the lab and interestingly , it hasn't just been running YOLO.

Some of the things people have used the lab for:

• comparing FP16 / FP32 / INT8 performance
• measuring actual inference latency and FPS on Jetson
• running the same model at 25W, 15W and 7W
• watching GPU, CPU, memory, temperature and power while the model runs
• testing DeepStream / GStreamer pipelines with multiple video streams
• finding out how many camera feeds a board can realistically handle
• checking whether a Python/CUDA/framework stack actually works properly on ARM64
• taking a model developed on a workstation and seeing what happens when it finally hits the target hardware

One use case we found particularly interesting was a researcher running the same model across different power modes and precisions.

The question wasn't just:

"How fast is the model?"

It was more like:

What performance can I get while staying inside my power budget?

Another team had an even more basic problem.

They already had their CV pipeline.

They simply needed to know:

Will this software stack actually run on Jetson before we commit to the hardware?

That kind of test can save quite a bit of pain later.

We've also added JupyterLab now, which is what I'm showing in the attached video.

So you can basically go:

browser -> Jupyter notebook / terminal -> physical Jetson -> run your workload -> watch the device metrics

The board isn't being emulated and this isn't an x86 GPU VM pretending to be a Jetson. The workload is running on the actual Jetson hardware.

The goal isn't really to replace owning a Jetson.

If you're developing on one every day, you should probably own one.

The use case we're trying to solve is the stage before that:

I have a model / pipeline / idea. Before I spend money on hardware, what actually happens when I run it on the board?

That's also why I increasingly think TOPS is one of the least useful numbers when you're making the final hardware decision.

FPS, latency, memory, thermals, power draw and whether your stack even runs are usually much more useful.

If anyone here has a slightly unusual workload you think we should test, I'd genuinely like suggestions.

TensorRT, DeepStream, OCR, multi-camera CV, quantisation, small local models, power-constrained inference, whatever.

Would also be interested to know:

If someone gave you a Jetson Orin for 3 hours right now, what would you benchmark first?

https://edgeai.aiproff.ai

Full disclosure: this is a product my team at AiProff.ai built, and it has a tier based pricing for access. A 3-hour slot currently starts at ₹399 or $6 and all the experiments shared here are with user permission.

Some of you might remember me experimenting with Evopien on the Jetson Orin Nano.

The original goal was already pretty ambitious: build a local AI companion that could eventually see, listen, speak, remember people and become physically embodied.

The Nano taught me a lot, but the resource limits were brutal.

I've now moved the project to Jetson AGX Thor and finally recorded the first complete demo of the current system.

It's running voice conversation, interruption handling, English/Spain Spanish, continuous camera perception, local visual reasoning, recent visual context, internet retrieval and session context together.

The interesting part isn't just that a larger model runs on Thor.

The real improvement is that I can keep several systems alive together instead of benchmarking one model in isolation.

There is continuous perception running while the conversation stack is active. Speech still needs to respond quickly. TTS needs to run. Internet work needs to happen without blocking everything. And when I interrupt the assistant, stale generation and speech need to actually stop.

The current local cognition/VLM is Qwen3.8-27B, but I've deliberately designed the project so Qwen is replaceable. The Core above it owns the important state and authority.

So compared with simply running ChatGPT or another hosted assistant, the point isn't that my 27B model is smarter.

The point is that I'm building the entire embodied system around it locally and controlling what each component is allowed to do.

Here's the current demo:

https://www.youtube.com/watch?v=sQhTGGIg4yo

There are definitely still rough edges, but compared with where this started on the Nano, the difference is pretty crazy.

Next up is governed long-term memory and identity continuity.