Sep 24, 17:03

Overview

We’re going to have a discussion with Grok about two things:

  1. The ability for us to build a server inside of R1 Cord.
  2. Some research on how we can do a chalkboard-style rapid viz: an animated drawing with a hand, the pencils and so on.

Let’s start with the first one.


Part 1: The R1 Cord Server

My current setup

I have a server app that sits on a desktop and talks to my Rabbit, which I custom-programmed to send files to my desktop. I do it through Cloudflare with a tunnel, over the internet.

Grok: You’ve got a Rabbit R1 you’ve custom-programmed to push files out over the internet. Instead of exposing your desktop directly, you route it through a Cloudflare tunnel, so the connection comes in securely without opening ports on your home network. The desktop runs a server app that receives the files on the other end. That’s a solid setup: the Cloudflare tunnel handles the ingress and keeps your machine off the public internet, and the Rabbit just needs outbound access to reach the tunnel endpoint.

What I want: a server secure enough not to need Cloudflare

I want to talk about the server app. I’d like to make the server secure enough not to require Cloudflare, because asking a user to configure Cloudflare to create a tunnel is ridiculous in terms of user-friendliness. Ideally I’d just run the server as a service, as it is now, and lock it down enough that the user of the Rabbit can get to it. Typically this is a one-to-one deal.

Grok: Tunnels are powerful, but they’re a pain for a regular person to set up. For a one-to-one setup like yours, something like Tailscale or ZeroTier is probably the sweet spot. You install a tiny client on the Rabbit, run a node on the desktop…

I cut in: no, I don’t want to do that either. You basically have to have an executable on the PC that you can install and run, and the Rabbit is just an APK. I don’t want to go through a complete configuration mode if I don’t have to.

Can I open a port on my desktop without touching the router?

Let’s back up. Is it possible to open a port on my desktop without going through my Wi-Fi router? Is there a program that does that?

Grok: Short answer, no — not from inside the desktop alone. Your desktop sits behind the router, which translates your private IP to the public one the internet sees. Any incoming connection has to hit the router first, and the router has to know to forward it to your desktop. The desktop can’t punch through that on its own.

The closest thing to “just run it” without manual router config is UPnP: the app asks the router to open the port automatically. Most home routers support it, but a lot of people have it disabled or don’t know it’s on. It’s not guaranteed, and some ISPs block it entirely.

How Cloudflare gets around the router

So what does Cloudflare do, then? I don’t mess with the router that I’m aware of. Does Cloudflare just bypass the router somehow?

Grok: Cloudflare doesn’t bypass your router at all; your router still has to allow the outbound connection. What Cloudflare does is flip the direction. Instead of the internet reaching into your network, your desktop reaches out to Cloudflare’s edge servers first — an outbound connection. Routers almost always allow outbound traffic, so nothing on the router needs to change. Once that connection is up, Cloudflare’s edge holds it open, and any incoming request that hits your Cloudflare hostname gets routed back down through that same outbound pipe.

So the tunnel is really just a long-lived outbound connection that Cloudflare multiplexes return traffic over. That’s why you never touch the router: you’re not opening anything inbound, just making a normal outbound call, and Cloudflare does the rest on their side.

How Dropbox does it

How does a program like Dropbox handle it? I’m accessing files on the Dropbox server without setting up Cloudflare or any other tunneling software.

Grok: Dropbox flips the model completely. Your desktop never receives an inbound connection. The Dropbox client on your PC makes an outbound connection to Dropbox’s servers and sits there waiting. When you want a file, your phone or another device talks to Dropbox’s cloud, and Dropbox pushes the file down to your desktop through that already-open outbound pipe.

The key difference is where the files live: on Dropbox’s servers, not on your machine. There’s no server on your desktop that the outside world needs to reach. Your desktop is just a client pulling and pushing data to a central server that everyone else also talks to.

That’s the fundamental trade-off:

  • Cloudflare Tunnel: your desktop is the server, and Cloudflare is the middleman.
  • Dropbox: Dropbox is the server, and your desktop is just another client.

If you want the files to stay on your own hardware but still be reachable without touching the router, you’d need something in between: a relay that both sides connect outbound to — a kind of mini Dropbox, but pointed at your machine instead of a cloud store.

Could Google Drive or Dropbox act as the relay?

Just for the sake of discussion: is there a way to configure Google Drive to handle any of this? Could I use ACK files on Google Drive, or even on Dropbox?

Grok: Absolutely, and it’s a clean fit. You could treat a shared Drive or Dropbox folder as your relay. The Rabbit uploads files to a designated folder. Your desktop app watches that folder, either through the Drive or Dropbox API or just by syncing the folder locally and picking up new files as they land. No server, no tunnel, no router config. Both sides talk outbound to Google or Dropbox, and the folder is the meeting point. The trade-offs are latency and API limits: you don’t get a real-time push; you’re pulling or relying on syncing.

Privacy is the whole point

I don’t need real-time push; that’s not something I’m worried about. What I am worried about is privacy.

The whole point of this product is that you can have discussions with this converted Rabbit. It’s a real-time audio recorder — that’s what it does. The product is called R1 Cord; you can look it up. The point is that you don’t want your conversations in the cloud on somebody else’s server.

I asked about Dropbox and Google Drive only because I wanted to understand what kinds of architectures may or may not work.

Other options: my own server

What if you had your own PHP server, on cPanel or something like that? You could obviously do it there, but most people don’t have that. I’m trying to think of what most people have that they can use.

Let’s back up and talk about Tailscale now.

Tailscale

Grok: Tailscale is worth a serious look for exactly your privacy concern. It’s a mesh VPN built on WireGuard, and the privacy story is pretty good for your use case.

  • Both the Rabbit and your desktop install a tiny Tailscale client. On Android that’s straightforward; on the desktop it’s one installer.
  • They both authenticate to Tailscale’s coordination servers just long enough to exchange keys and find each other.
  • After that, the audio data flows directly between the two devices, encrypted end to end. Tailscale’s servers never see your conversations; they only know that two nodes are connected.
  • If a direct peer-to-peer path isn’t possible, it falls back to encrypted relay servers. Even then the data is encrypted and Tailscale can’t read it.

The big win is that your desktop server app just listens on the Tailscale IP address, and the Rabbit connects to that same address. No router config, no port forwarding, no Cloudflare, no third-party file storage holding your audio. The desktop is the server, the Rabbit is the client, and Tailscale is just the private network pipe between them.

The free tier covers up to 100 devices and three users, which is more than enough for a one-to-one product like R1 Cord.

The one thing to think through is the initial setup. The user has to install Tailscale on both ends and log in once. That’s a couple of extra steps compared to just installing an APK, but it’s a one-time thing, and it’s about as painless as mesh networking gets.

Tailscale vs. Cloudflare

I wanted to hear more about the difference between the two.

Grok: The core difference is architecture and who you’re trusting.

Cloudflare Tunnel: your desktop connects outbound to Cloudflare’s edge, and every request from the Rabbit has to pass through Cloudflare’s servers on the way in and back out. Cloudflare sits in the middle of every single packet. Even though the connection to Cloudflare is encrypted, Cloudflare terminates that connection at their edge and decides what gets forwarded to your machine. So you’re trusting Cloudflare not just with routing but with being the gatekeeper for your service.

Tailscale: peer-to-peer by default. The Rabbit and your desktop find each other, usually directly over the internet, sometimes through a relay if a direct path is impossible. The data is encrypted end to end between the two devices. Tailscale’s coordination servers only handle the initial handshake — exchanging keys and working out how the two nodes can reach each other. After that, Tailscale is out of the data path entirely. They can’t read your audio even if they wanted to, because they never have the keys.

The practical difference for your product: with Cloudflare, you’re building on someone else’s public-facing infrastructure, and your service is reachable from the entire internet through that Cloudflare hostname. With Tailscale, you’re building a private network that only your two devices belong to. Nothing is exposed to the public internet. The Rabbit connects to a Tailscale IP, not a public domain. There’s no URL.

Which is more secure, and which is easier for the user?

Security — Tailscale wins, and it’s not close for your use case. The data path is end-to-end encrypted between the Rabbit and your desktop, and Tailscale’s servers never touch your audio. With Cloudflare, the edge actively proxies every request, so even though the tunnel is encrypted, Cloudflare is a trusted intermediary in the middle. For a product whose whole selling point is that your conversations stay private, that distinction matters a lot.

Ease of setup — Cloudflare is simpler on paper. You install one thing on the desktop, get a tunnel token, and you’re done; the Rabbit just hits a URL. But Tailscale has gotten really close. The desktop install is one click; the Rabbit needs the Tailscale app from the Play Store and a login, and after that it’s automatic. The difference is maybe two extra taps on the Rabbit side. For a non-technical user both are doable, but Tailscale is more of a “log in once and forget it” experience, whereas Cloudflare requires you to manage tunnel credentials and a hostname.

If Grok had to pick for R1 Cord: Tailscale gives better security with nearly the same setup effort. The only real cost is the extra login step on the Rabbit, and that’s a one-time thing.

Tailscale on the Rabbit: footprint and install

I had two concerns:

  1. Memory footprint and CPU. I need to know whether it will chew up cycles, because the Rabbit is an underpowered device.
  2. The OS. The OS you put on the Rabbit to hack it is very minimal — I think it’s Android 12 or maybe 13; probably Android 13 is what they give you to hack it with. It has to work with that, and you can’t go to a Play Store to download it.

So: can you download and install Tailscale without the Play Store? Is it open source?

(At this point the conversation got interrupted by some kind of issue, and I had to call Grok several times — “Hey, Grok… can you hear me?” — before it came back.)

I restated the situation: we’ve hacked a Rabbit that has a recording app, running Android 13 with my own APK, and it’s the only device. The Rabbit is just going to be a little utility device — a dedicated offline/online voice recorder. When it goes online, it uploads its files to my computer at home. There’s no Play Store and no user ID or Google account on the Rabbit. I wanted to know:

  • The memory footprint of Tailscale on the Rabbit.
  • How to install it without the Play Store or a Google account.
  • Whether Tailscale is open source, and if so, whether I can put it inside my own APK or install its own APK directly.

Grok (after checking the latest):

Open source and sideloading. Yes, Tailscale is fully open source, and you can install it as a plain APK with no Google account involved. Official stable APKs are at pkgs.tailscale.com/stable/#android, and the same builds are mirrored on the Tailscale Android GitHub releases page, so you can grab them with Uptanium (likely Obtainium) or just sideload directly. F-Droid also builds from the same source if you prefer that route.

Memory. Tailscale’s baseline on mobile is roughly 10 to 15 MB of RAM at idle. That comes from their own profiling on iOS, where they were capped at 15 MB total and sat around 13. On Android it runs a bit higher, but it’s still in that ballpark — well under 20 MB steady state. For a dedicated voice recorder that’s plenty, especially since the Rabbit R1 has around 4 GB of RAM, even after the Android conversion eats some of it.

Authentication without a Google account. The app has a “Sign in with other” option that supports any SSO provider. Or you can use an auth key from the Tailscale admin console for a headless or kiosk-style setup. There’s also a QR code flow: the device displays a code and you approve it from your admin console on another machine.

One caveat. Tailscale only gives you the network tunnel. To actually push files to your home computer, you still need something like an SFTP server, an SMB share, or a simple upload endpoint running on the receiving end. Tailscale just makes that endpoint reachable as if it were on your local network.

Installing and authenticating over USB-C

What I really wanted to understand is exactly how to register the Tailscale app on the Android. The server app on the PC has a USB-C cord connected to the Rabbit, so I assume I can install Tailscale over that cord. Can I also authenticate it at the same time I install it, if the servers are already set up with Tailscale?

Grok: Yes, you can do both over that USB-C connection. Since your PC already runs Tailscale, the cleanest path is:

  1. On the Rabbit, enable developer options and turn on USB debugging.
  2. Plug it into the PC and run adb devices from a terminal on the PC to confirm it shows up.
  3. Grab the official APK from pkgs…

I stopped it there — I think I know how to do all that. I just wanted to confirm that Tailscale is a better, more secure approach than a Cloudflare tunnel.

Conclusion: Tailscale is the better fit

Grok: Yes. For your setup, Tailscale is the better fit. A Cloudflare tunnel works by punching a hole through Cloudflare’s edge network to expose a service on your home machine, which means that machine has to run a tunnel daemon and you’re relying on Cloudflare’s infrastructure as a middleman. Tailscale instead builds a private mesh directly between your devices using WireGuard, so the connection is end-to-end encrypted with no third party in the path, and your home PC doesn’t need to expose anything. For a dedicated recorder pushing files to one specific machine, that direct peer-to-peer approach is simpler, lighter and more secure.

Multiple servers on one computer

Can I have multiple servers on my computer, each with a different Tailscale endpoint?

Grok: Yes. Each instance just needs its own state directory and socket path so they don’t collide.

  • Linux: launch separate Tailscale processes with different --statedir and --socket flags. Each registers as its own node with its own Tailscale IP. You can tag them differently or put them on different tailnets entirely.
  • Windows: more awkward, since there’s no native multi-instance support, but you can run them in separate containers or WSL instances to get the same effect.

Serving a web page over Tailscale

Can I create a tiny server and serve a web page from my desktop computer using Tailscale?

Grok: Absolutely. Tailscale has a built-in feature called Serve that does exactly that. You run a tiny web server on your desktop — something like a Python HTTP server or Nginx — then point Tailscale Serve at it with a command like tailscale serve 8080. That makes the page available at your machine’s Tailscale IP or MagicDNS name, but only to devices on your tailnet. Your Rabbit, your phone, anything connected to your Tailscale network can hit it, and nothing outside can. If you ever wanted it public, you’d use Funnel instead, but for your use case Serve is the right call.


Part 2: Whiteboard-Style Animated Drawing

What the technique is called

I wanted to talk about the sketch-drawing technique you see in videos. I was trying to think of the company that did it and who created it. The idea is that you see a hand at a whiteboard that starts drawing something, with a narrator in the background.

Grok: That’s usually called a whiteboard animation, also known as a sketch animation or doodle video. The big names in that space are VideoScribe, Doodly and Common Craft. Common Craft basically pioneered the explainer style with simple hand-drawn visuals and a calm narrator. RSA Animate took it further with more artistic, fast-paced whiteboard sketches.

RSA Animate does a really good job.

What I want to make

Say I want to create a video in the style of RSA Animate. I don’t even need the hand and the pencil in the picture; I just want to see it being drawn on a whiteboard. How would I go about creating a video like that with AI? Would I need to build a custom tool first, or are there tools out there that already do it?

Grok (after checking): You don’t need to build anything custom; there are several solid options.

  • Ancon AI is the closest match. You give it a topic or script; it writes the narration, sketches each scene stroke by stroke on a clean whiteboard and syncs the voiceover. It has a no-hand mode, so you get just the drawing effect without a visible hand.
  • animation.ai does something similar but starts from images you already have and animates them with an outline-first, no-hand option.

Are these open source or subscription-based? Grok: Mostly subscription-based. Ancon AI, Colpo and Animaker all run on monthly plans.

I want to build my own

OK — I want to make my own, or use open-source parts, but I definitely want to make my own. I have access to Claude and Codex, which can use the frontier AIs to drive this thing. This isn’t a commercial product; it’s a tool for me to create my own talking videos. I have a YouTube account, so I can just put them on there. So what are some ways to go about creating something like that?

The open-source path

Grok (after pulling up the open-source options): There’s a clean path here, and you don’t have to start from zero.

The drawing engine: Whiteboard-Animator (GitHub). It’s the best open-source render engine out there. MIT licensed, runs on CPU only, and needs no GPU or API keys for the core rendering. You feed it a clean whiteboard-style image, and it traces every stroke, writes text word by word, fills shapes with brush strokes, and paces it all to a narration audio file.

The AI pipeline around it:

  1. Claude or Codex takes your topic and writes a scene-by-scene script. Each scene is one idea, roughly 12 to 15 words, with a visual description.
  2. Send each scene description to an image model, such as Flux or GPT Image, and ask it for a clean black-ink-on-white illustration.
  3. Run each image through Whiteboard-Animator with a matching narration clip.
  4. FFmpeg stitches the scenes together into one video.

Narration: ElevenLabs if you want a polished voice, or Edge TTS, which is free and needs no API key.

HandDraw-Skill is another project that does almost exactly this end to end. It uses SVG, Remotion, FFmpeg and free Edge TTS, and it’s designed to be driven by a coding agent like Claude Code or Codex. You could fork it as a starting point and customize the visual style to match RSA Animate more closely.

The one thing Whiteboard-Animator doesn’t do is generate the images; it only animates what you give it. The image-generation step is where you lean on Claude or Codex to craft good prompts or call an image API directly.

How does the renderer actually work?

I asked Grok to figure out two things:

  • A. How does it know where to put the pencil based on the script? Say I have a picture of an apple, an orange and a pear. I start with a white screen and start talking about the apple first. How does it know to draw the apple?
  • B. How is it drawing? Is it removing a mask — creating a raster mask and exposing only the parts of the line where the cursor or pen passes over? Or is it vectorizing the whole thing and drawing it using the vector shapes as paths?

Grok: Those are the two hardest parts of the whole thing.

A. Drawing order: spatial heuristics, not script understanding

It doesn’t understand the script. There’s no semantic matching between “apple” in the narration and the apple in the image. It uses spatial heuristics:

  • Containers get drawn before their contents.
  • Shapes before their labels.
  • Text in reading order.
  • Small dots attach to whatever glyph they belong to.

So if your apple, orange and pear are three separate blobs on a white background, it picks one based on position — probably left to right, top to bottom — not because it knows you’re talking about the apple first.

You can override that with a region plan: a JSON file where you explicitly list each region and its reveal order. There’s also an optional Gemini step, where you pass in the image plus your narration text and Gemini proposes which regions to draw and in what order. Even then, the final order comes from that explicit plan, not from real-time speech understanding. The smart part is a one-time LLM pass that annotates your image, not the renderer itself.

B. Drawing method: raster, not vector

It’s raster — no SVG, no path tracing in the vector sense. Here’s what happens:

  1. It scans the image for connected blobs of non-white pixels. Anything darker than about 240 gray becomes a component.
  2. A small text-detector model flags which blobs are words, so those get written left to right instead of traced as outlines.
  3. For each component, it computes a skeleton — basically the centerline of the stroke — and starts revealing from a real endpoint, like the tip of a V.
  4. Closed shapes get a single traveling front that walks around the boundary.
  5. Fills get an outline pass first, then either an angled sweep or bristled brush strokes, depending on size.
  6. Anything with junctions, like an X or a grid, gets decomposed into sequential pen paths, so it doesn’t just bloom outward from the center.
  7. Each pixel gets a reveal timestamp. As frames render, finished pixels get committed permanently, and only the pixels currently being drawn get a fade blend.
  8. Everything streams out through FFmpeg.

So it’s a pixel-level mask reveal guided by skeleton geometry — not vector paths, but not a dumb left-to-right wipe either. The skeleton tracing is what makes it feel like a hand drawing rather than a curtain opening.

The trade-off is that it only works well on clean ink-on-white illustrations. Photos, gradients and textured backgrounds fall apart, because the connected-component detection can’t separate meaningful strokes from noise.

Brainstorm: could AI video do this?

I was brainstorming: has anyone tried this using AI video? With AI video you could give it a picture and say something like: “Progressively disclose this in this order. Draw the apple first, then shade it red. Then draw the pear second and shade it a golden yellow. Finally, in the bottom right-hand corner, zoom in, draw the orange last and shade it orange.”

Grok: Yes, people have tried exactly that, and there’s even a research project built for it called VideoSketcher. An LLM takes your prompt, breaks the subject into semantic parts and decides the drawing order — for example, cake base first, then frosting, then candles. That plan is fed to a video diffusion model trained on artist SVGs, where each stroke animates along its path. So the model literally generates a video of strokes appearing progressively on a blank canvas in a meaningful order, not a random wipe.

The catch: it’s a research prototype, not a polished product you can just open and use. And the control is semantic, not pixel-precise. You can’t say “draw the apple, then shade it red, then zoom to the bottom right for the orange.” You get a rough order of parts, but the model decides the exact strokes.

What creators actually do in practice is the start-and-end-frame trick. You generate a blank whiteboard as frame one, a whiteboard with just the apple outline as frame two, then a version with the apple shaded red, then one with the pear added, and so on. You chain those as keyframes through Seedance or Veo, and the model interpolates the drawing motion between each state. Kling’s motion brush helps too: you paint over the region you want to animate and leave the rest static, so only the apple moves while everything else holds still.

The honest answer: the idea works, but nobody has nailed fine-grained, script-driven, stroke-level control with a pure video model yet. Deterministic engines like Whiteboard-Animator still win on precision. Video models win on an organic, hand-drawn feel; they just can’t follow a strict order.

Practical takeaway: a hybrid

Grok:

  • If you want pixel-perfect control over drawing order, stick with a deterministic renderer like Whiteboard-Animator and let an LLM just plan the regions.
  • If you want the organic, hand-drawn feel where the strokes look alive, lean on a video model, but accept that you’ll be chaining keyframes and babysitting the order.

Most people building this for real end up with a hybrid: generate the clean illustration with an image model, run it through a stroke renderer for the drawing motion, then use a video model only for camera moves or shading transitions where you don’t need exact stroke control. That gets you maybe 80% of the RSA Animate look without fighting the model on every frame.

My idea: draw the whole board big, then add the camera

Grok offered to sketch the hybrid pipeline in code. No — here’s what I want to think about.

Picture a complete RSA Animate-style whiteboard drawing. When you zoom out at the end, there are probably 30 or 40 different drawings on the whiteboard. You started at the top left and kept drawing, and you moved, panned and scanned, went back, zoomed in a little, zoomed out a little — but at the end you’re way out. To create that type of video, it seems to me you’d want to create the video at a super-high resolution first, then add the camera movements based on the narration second.

Grok: That makes total sense, and it’s how the real RSA Animate videos were built. Cognitive, the studio behind RSA Animate, worked on a giant canvas, sometimes several times the final frame size, and the camera was a separate layer that moved around it.

So you render the full whiteboard at, say, 4K or 8K, with every drawing in its final position. Then you define a camera path — a sequence of keyframes with timestamps, for example:

  • At 3 seconds, be zoomed into the top left at 200%.
  • At 7 seconds, pan right to the apple.
  • At 12 seconds, zoom out to show everything.

That camera path is driven by your narration timestamps, so the drawing and the voice stay locked together. Tools like Remotion handle this natively; it’s basically a React component where you animate a transform on a big image.

Generating the extremely large canvas

I know Remotion. So what tool would I use to script creating that extremely large frame?

Grok: You generate it as a grid of tiles. Each tile is generated at normal resolution, say 1024×1024, with prompts that describe what’s in that region and what bleeds into the neighboring tiles, so the seams match up. Then you composite them with a small overlap and a soft blend at the edges, and you have one giant canvas, maybe 8K or 16K total. The trick is the prompts: you feed each tile generation the context of its neighbors, so a drawing that straddles two tiles doesn’t get cut in half.

Wait — the finished render comes first?

Let me back up. Are you saying you create the finished render first?

Grok: Yes, exactly. You generate the entire finished whiteboard — all 30 or 40 drawings, fully inked and shaded, in their final positions — as one static image first. Nothing is animated yet. Then in Remotion you load that single image and animate a virtual camera window that pans, zooms and reveals pieces of it over time, synced to your narration. The drawing motion comes from the camera revealing what’s already there, not from generating strokes on the fly. That’s what gives you the RSA Animate feel, where the whole board exists from the start and the camera discovers it piece by piece.