u/Lumpy_Ice6855

I’ve added a new Roadmap mode to DStudio, my local-first desktop interface for running DeepSeek V4.

You describe what you want to learn, your current level and available time. You can also attach PDFs or include documentation links directly in the prompt. DStudio then generates a prerequisite-aware visual roadmap instead of a normal chat response.

https://preview.redd.it/b4ypy4ycu4ih1.png?width=3308&format=png&auto=webp&s=fa1e60909a4b42d7a3356f03ae0ac990cfab2cc6

Clicking Study on any roadmap block opens a dedicated Tutor chat for that specific topic. The tutor already knows the roadmap context, learning objective and exercise, so it can teach the subject step by step, answer questions, provide examples, assign exercises and correct your work.

https://preview.redd.it/sj98vpoeu4ih1.png?width=3450&format=png&auto=webp&s=ac4c5ad86939eba08d4eed1a861964019e9234d8

Leave a star if you want: https://github.com/sk8erboi17/DStudio/tree/main

I’ve added a new Roadmap mode to DStudio, my local-first desktop interface for running DeepSeek V4.

You describe what you want to learn, your current level and available time. You can also attach PDFs or include documentation links directly in the prompt. DStudio then generates a prerequisite-aware visual roadmap instead of a normal chat response.

https://preview.redd.it/jk1d0viat4ih1.png?width=3308&format=png&auto=webp&s=920d16de6ca8d7a2d9d5311949753b76de5e26c7

Clicking Study on any roadmap block opens a dedicated Tutor chat for that specific topic. The tutor already knows the roadmap context, learning objective and exercise, so it can teach the subject step by step, answer questions, provide examples, assign exercises and correct your work.

https://preview.redd.it/jrx1s2jut4ih1.png?width=3450&format=png&auto=webp&s=f740530acc6d567b82d22a46e95792941ba326be

Leave a star if you want: https://github.com/sk8erboi17/DStudio/tree/main

I’m building DStudio, an open-source desktop app centered around DeepSeek V4. DeepSeek remains the main reasoning model and manages the conversation, while smaller local models handle specialized tasks:

- Qwen2.5-VL reads images
- Qwen Image generates and edits images
- Qwen3 Embedding searches documents semantically
- Poppler extracts PDF text and page information

This ecosystem exists because DeepSeek V4 is excellent for reasoning and long context, but loading every multimodal capability inside the same large model would be inefficient. DStudio routes tasks to specialized models and then returns their results to DeepSeek for the final answer.

I recently added long-PDF retrieval. DeepSeek decides whether to create an overview, read an exact physical page or search the entire document. For semantic search, DStudio creates and caches one embedding per page, retrieves the six most relevant pages and sends only those to DeepSeek.

On a 1,000-page test PDF, it found a passage placed on page 777 from a paraphrased question. Initial indexing took about 25 seconds; later searches took around 0.23 seconds.

I’m looking for feedback: should retrieval use page embeddings or overlapping chunks? Should I add BM25 or a reranker? And how would you efficiently support scanned 1,000-page books?

https://github.com/sk8erboi17/DStudio

I’m building DStudio, an open-source desktop app centered around DeepSeek V4. DeepSeek remains the main reasoning model and manages the conversation, while smaller local models handle specialized tasks:

- Qwen2.5-VL reads images
- Qwen Image generates and edits images
- Qwen3 Embedding searches documents semantically
- Poppler extracts PDF text and page information

This ecosystem exists because DeepSeek V4 is excellent for reasoning and long context, but loading every multimodal capability inside the same large model would be inefficient. DStudio routes tasks to specialized models and then returns their results to DeepSeek for the final answer.

I recently added long-PDF retrieval. DeepSeek decides whether to create an overview, read an exact physical page or search the entire document. For semantic search, DStudio creates and caches one embedding per page, retrieves the six most relevant pages and sends only those to DeepSeek.

On a 1,000-page test PDF, it found a passage placed on page 777 from a paraphrased question. Initial indexing took about 25 seconds; later searches took around 0.23 seconds.

I’m looking for feedback: should retrieval use page embeddings or overlapping chunks? Should I add BM25 or a reranker? And how would you efficiently support scanned 1,000-page books?

https://github.com/sk8erboi17/DStudio

I'm considering studying Christopher Bishop's Pattern Recognition and Machine Learning to strengthen my understanding of the theoretical foundations of machine learning.

Although the book is almost 20 years old, it is still frequently recommended. For someone primarily interested in the underlying theory rather than the latest deep learning techniques, how well has it held up? Are there any modern texts that cover the same fundamentals more effectively?

I know Bishop's Pattern Recognition and Machine Learning is almost 20 years old now. Is it still worth studying in 2026, or are there better modern alternatives? I'm mainly interested in building a solid theoretical foundation.

I've been building DStudio, a local-first desktop app (chat / agent / design) on top of antirez's ds4, his from-scratch C engine that runs DeepSeek V4 entirely on your own machine. ds4 is the engine.
DStudio is the UI + agent layer on top. No API, no cloud.

The mode I've been hammering on is Build mode: it turns a chat goal into a real, runnable Django web app. The flow:

It asks you questions first. You say what you want ("a small second-hand clothing marketplace"), and instead of guessing it interviews you one question at a time, features & scope, the must-have pages, auth, the data, the visual style, each as a clickable card (pick an option or write your own). Like Claude Code's questions, inside the chat.

It tries to design/plan it. Once it has enough, it proposes a concrete plan: the list of pages + a one-line style direction. You confirm (or keep refining in the chat). Nothing gets written until you approve the plan.

It builds page-by-page, switching between two agents. A deterministic driver, not the model walks the plan. For each page it switches engines: the design agent makes the page's look (style-locked to the first approved page), then the coding agent wires that exact page into the Django backend (models, views, urls, forms, templates). "Done" is decided by the filesystem (the expected file exists), never by the model saying so. You're in the loop exactly once: approve the first page's look, which locks the design tokens for the rest.

Why a driver + agent-switch instead of one big autonomous loop? Running a local quant (ds4's Flash), a long hands-off loop loses the thread, declares itself finished early, drifts off-style. Small verified steps, design then wire, one page at a time, survive a weak local model far better.

Plus a live build console (pages stack done ✓ / in progress / to do, what it's doing right now, which skills/craft packs it pulled), colored +/- diffs for file edits, and the model's reasoning visible inline, so a long local-model turn never looks frozen.

https://preview.redd.it/it046uwpt96h1.png?width=2888&format=png&auto=webp&s=67c74a2dc0d38dee64b347d27cb8d9124d2bf252

Heads up on the video: there's a demo clip attached, but fair warning, it was recorded before these latest UI changes, so it doesn't show the new build console, the +/- diffs or the chat's cosmetic refresh yet. Sorry about that, I'll record an updated one soon.

Credit where it's due: the engine is antirez's ds4, DStudio just wraps it with a UI and the agent/design/build flows.

Link to youtube to see results. jump to 3:28 for the finished result.

Leave a star on DStudio repo: github.com/sk8erboi17/DStudio

I've been building DStudio, a local-first desktop app (chat / agent / design) on top of antirez's ds4, his from-scratch C engine that runs DeepSeek V4 entirely on your own machine. ds4 is the engine.
DStudio is the UI + agent layer on top. No API, no cloud.

The mode I've been hammering on is Build mode: it turns a chat goal into a real, runnable Django web app. The flow:

It asks you questions first. You say what you want ("a small second-hand clothing marketplace"), and instead of guessing it interviews you one question at a time, features & scope, the must-have pages, auth, the data, the visual style, each as a clickable card (pick an option or write your own). Like Claude Code's questions, inside the chat.

It tries to design/plan it. Once it has enough, it proposes a concrete plan: the list of pages + a one-line style direction. You confirm (or keep refining in the chat). Nothing gets written until you approve the plan.

It builds page-by-page, switching between two agents. A deterministic driver, not the model walks the plan. For each page it switches engines: the design agent makes the page's look (style-locked to the first approved page), then the coding agent wires that exact page into the Django backend (models, views, urls, forms, templates). "Done" is decided by the filesystem (the expected file exists), never by the model saying so. You're in the loop exactly once: approve the first page's look, which locks the design tokens for the rest.

Why a driver + agent-switch instead of one big autonomous loop? Running a local quant (ds4's Flash), a long hands-off loop loses the thread, declares itself finished early, drifts off-style. Small verified steps, design then wire, one page at a time, survive a weak local model far better.

Plus a live build console (pages stack done ✓ / in progress / to do, what it's doing right now, which skills/craft packs it pulled), colored +/- diffs for file edits, and the model's reasoning visible inline, so a long local-model turn never looks frozen.

https://preview.redd.it/it046uwpt96h1.png?width=2888&format=png&auto=webp&s=67c74a2dc0d38dee64b347d27cb8d9124d2bf252

Heads up on the video: there's a demo clip attached, but fair warning, it was recorded before these latest UI changes, so it doesn't show the new build console, the +/- diffs or the chat's cosmetic refresh yet. Sorry about that, I'll record an updated one soon.

Credit where it's due: the engine is antirez's ds4, DStudio just wraps it with a UI and the agent/design/build flows.

Link to youtube to see results. jump to 3:28 for the finished result.

Leave a star on DStudio repo: github.com/sk8erboi17/DStudio

I've been building DStudio, a local-first desktop app (chat / agent / design) on top of antirez's ds4, his from-scratch C engine that runs DeepSeek V4 entirely on your own machine. ds4 is the engine.
DStudio is the UI + agent layer on top. No API, no cloud.

The mode I've been hammering on is Build mode: it turns a chat goal into a real, runnable Django web app. The flow:

It asks you questions first. You say what you want ("a small second-hand clothing marketplace"), and instead of guessing it interviews you one question at a time, features & scope, the must-have pages, auth, the data, the visual style, each as a clickable card (pick an option or write your own). Like Claude Code's questions, inside the chat.

It tries to design/plan it. Once it has enough, it proposes a concrete plan: the list of pages + a one-line style direction. You confirm (or keep refining in the chat). Nothing gets written until you approve the plan.

It builds page-by-page, switching between two agents. A deterministic driver, not the model walks the plan. For each page it switches engines: the design agent makes the page's look (style-locked to the first approved page), then the coding agent wires that exact page into the Django backend (models, views, urls, forms, templates). "Done" is decided by the filesystem (the expected file exists), never by the model saying so. You're in the loop exactly once: approve the first page's look, which locks the design tokens for the rest.

Why a driver + agent-switch instead of one big autonomous loop? Running a local quant (ds4's Flash), a long hands-off loop loses the thread, declares itself finished early, drifts off-style. Small verified steps, design then wire, one page at a time, survive a weak local model far better.

Plus a live build console (pages stack done ✓ / in progress / to do, what it's doing right now, which skills/craft packs it pulled), colored +/- diffs for file edits, and the model's reasoning visible inline, so a long local-model turn never looks frozen.

https://preview.redd.it/it046uwpt96h1.png?width=2888&format=png&auto=webp&s=67c74a2dc0d38dee64b347d27cb8d9124d2bf252

Heads up on the video: there's a demo clip attached, but fair warning, it was recorded before these latest UI changes, so it doesn't show the new build console, the +/- diffs or the chat's cosmetic refresh yet. Sorry about that, I'll record an updated one soon.

Credit where it's due: the engine is antirez's ds4, DStudio just wraps it with a UI and the agent/design/build flows.

Link to youtube to see results. jump to 3:28 for the finished result.

Leave a star on DStudio repo: github.com/sk8erboi17/DStudio

I'm building DStudio a private, local-first AI workspace on top of DeepSeek V4. Chat, a coding agent, and a real design studio, all on your own hardware. Nothing leaves the device: no cloud, no telemetry, no subscription. It's a UI on top of antirez's ds4, the local DeepSeek V4 inference engine.

The bet: a frontier-class model that's entirely yours deserves more than a chat box. DStudio turns it into a place to think, code, and design and you can reach it from any device in your home.

What works today:

Use it from your phone (or any device on your Wi-Fi). Localhost-only by default; flip one switch and the same chats open on your phone, tablet, another laptop — while the model stays on your desktop. The engine never leaves 127.0.0.1 (same-origin /v1 reverse proxy), so there's nothing to configure on the client. Chats sync across devices.

A design studio on a local model (ds4-design). Not a chat that spits out HTML — a designer's pipeline: structured brief -> several distinct directions -> every screen on an infinite canvas -> refine by describing the next change -> export as a zip.

https://preview.redd.it/nnjm9seim26h1.png?width=3454&format=png&auto=webp&s=e83f9871cf9a26e4ba94c18c0f364dac2af35a5f

A coding agent that reads/edits files and runs commands, with clean structured output via a reversible build-time patch (the upstream engine source stays pristine).

Plus: 100% local & private (strict CSP), one self-contained binary (the whole UI is a single vanilla HTML file in a small C launcher), macOS-first with Linux builds too.

https://preview.redd.it/o3t1gm1mm26h1.png?width=3454&format=png&auto=webp&s=ffdd70d19b5de1ee0187f90277a70a48776cb3bc

Where it's going:

• Design studio — pushing fidelity and faster refine loops (in progress).
• Cowork — collaborative sessions: share a workspace and build alongside the model, together.
• MCP integration — so the agent can plug into your own tools and data sources.

Requires a local build of antirez's ds4 + DeepSeek V4 GGUF weights. Heads up — it's heavy: in 2-bit the "Flash" weights need ~96–128 GB RAM. The README has screenshots of every mode (chat, agent, the design pipeline, LAN) if you can't run it locally.

Repo (BSD-3): https://github.com/sk8erboi17/DStudio

Building in the open and early — would love feedback on the direction, especially the LAN/multi-device flow, the design pipeline, and what you'd want from Cowork / MCP. AMA.

I'm building DStudio a private, local-first AI workspace on top of DeepSeek V4. Chat, a coding agent, and a real design studio, all on your own hardware. Nothing leaves the device: no cloud, no telemetry, no subscription. It's a UI on top of antirez's ds4, the local DeepSeek V4 inference engine.

The bet: a frontier-class model that's entirely yours deserves more than a chat box. DStudio turns it into a place to think, code, and design and you can reach it from any device in your home.

What works today:

Use it from your phone (or any device on your Wi-Fi). Localhost-only by default; flip one switch and the same chats open on your phone, tablet, another laptop — while the model stays on your desktop. The engine never leaves 127.0.0.1 (same-origin /v1 reverse proxy), so there's nothing to configure on the client. Chats sync across devices.

A design studio on a local model (ds4-design). Not a chat that spits out HTML — a designer's pipeline: structured brief -> several distinct directions -> every screen on an infinite canvas -> refine by describing the next change -> export as a zip.

https://preview.redd.it/nnjm9seim26h1.png?width=3454&format=png&auto=webp&s=e83f9871cf9a26e4ba94c18c0f364dac2af35a5f

A coding agent that reads/edits files and runs commands, with clean structured output via a reversible build-time patch (the upstream engine source stays pristine).

Plus: 100% local & private (strict CSP), one self-contained binary (the whole UI is a single vanilla HTML file in a small C launcher), macOS-first with Linux builds too.

https://preview.redd.it/o3t1gm1mm26h1.png?width=3454&format=png&auto=webp&s=ffdd70d19b5de1ee0187f90277a70a48776cb3bc

Where it's going:

• Design studio — pushing fidelity and faster refine loops (in progress).
• Cowork — collaborative sessions: share a workspace and build alongside the model, together.
• MCP integration — so the agent can plug into your own tools and data sources.

Requires a local build of antirez's ds4 + DeepSeek V4 GGUF weights. Heads up — it's heavy: in 2-bit the "Flash" weights need ~96–128 GB RAM. The README has screenshots of every mode (chat, agent, the design pipeline, LAN) if you can't run it locally.

Repo (BSD-3): https://github.com/sk8erboi17/DStudio

Building in the open and early — would love feedback on the direction, especially the LAN/multi-device flow, the design pipeline, and what you'd want from Cowork / MCP. AMA.

I'm building DStudio a private, local-first AI workspace on top of DeepSeek V4. Chat, a coding agent, and a real design studio, all on your own hardware. Nothing leaves the device: no cloud, no telemetry, no subscription. It's a UI on top of antirez's ds4, the local DeepSeek V4 inference engine.

The bet: a frontier-class model that's entirely yours deserves more than a chat box. DStudio turns it into a place to think, code, and design and you can reach it from any device in your home.

What works today:

Use it from your phone (or any device on your Wi-Fi). Localhost-only by default; flip one switch and the same chats open on your phone, tablet, another laptop — while the model stays on your desktop. The engine never leaves 127.0.0.1 (same-origin /v1 reverse proxy), so there's nothing to configure on the client. Chats sync across devices.

A design studio on a local model (ds4-design). Not a chat that spits out HTML — a designer's pipeline: structured brief -> several distinct directions -> every screen on an infinite canvas -> refine by describing the next change -> export as a zip.

https://preview.redd.it/nnjm9seim26h1.png?width=3454&format=png&auto=webp&s=e83f9871cf9a26e4ba94c18c0f364dac2af35a5f

A coding agent that reads/edits files and runs commands, with clean structured output via a reversible build-time patch (the upstream engine source stays pristine).

Plus: 100% local & private (strict CSP), one self-contained binary (the whole UI is a single vanilla HTML file in a small C launcher), macOS-first with Linux builds too.

https://preview.redd.it/o3t1gm1mm26h1.png?width=3454&format=png&auto=webp&s=ffdd70d19b5de1ee0187f90277a70a48776cb3bc

Where it's going:

• Design studio — pushing fidelity and faster refine loops (in progress).
• Cowork — collaborative sessions: share a workspace and build alongside the model, together.
• MCP integration — so the agent can plug into your own tools and data sources.

Requires a local build of antirez's ds4 + DeepSeek V4 GGUF weights. Heads up — it's heavy: in 2-bit the "Flash" weights need ~96–128 GB RAM. The README has screenshots of every mode (chat, agent, the design pipeline, LAN) if you can't run it locally.

Repo (BSD-3): https://github.com/sk8erboi17/DStudio

Building in the open and early — would love feedback on the direction, especially the LAN/multi-device flow, the design pipeline, and what you'd want from Cowork / MCP. AMA.

I'm building DStudio a private, local-first AI workspace on top of DeepSeek V4. Chat, a coding agent, and a real design studio, all on your own hardware. Nothing leaves the device: no cloud, no telemetry, no subscription. It's a UI on top of antirez's ds4, the local DeepSeek V4 inference engine.

The bet: a frontier-class model that's entirely yours deserves more than a chat box. DStudio turns it into a place to think, code, and design and you can reach it from any device in your home.

What works today:

Use it from your phone (or any device on your Wi-Fi). Localhost-only by default; flip one switch and the same chats open on your phone, tablet, another laptop — while the model stays on your desktop. The engine never leaves 127.0.0.1 (same-origin /v1 reverse proxy), so there's nothing to configure on the client. Chats sync across devices.

A design studio on a local model (ds4-design). Not a chat that spits out HTML — a designer's pipeline: structured brief -> several distinct directions -> every screen on an infinite canvas -> refine by describing the next change -> export as a zip.

https://preview.redd.it/nnjm9seim26h1.png?width=3454&format=png&auto=webp&s=e83f9871cf9a26e4ba94c18c0f364dac2af35a5f

A coding agent that reads/edits files and runs commands, with clean structured output via a reversible build-time patch (the upstream engine source stays pristine).

Plus: 100% local & private (strict CSP), one self-contained binary (the whole UI is a single vanilla HTML file in a small C launcher), macOS-first with Linux builds too.

https://preview.redd.it/o3t1gm1mm26h1.png?width=3454&format=png&auto=webp&s=ffdd70d19b5de1ee0187f90277a70a48776cb3bc

Where it's going:

• Design studio — pushing fidelity and faster refine loops (in progress).
• Cowork — collaborative sessions: share a workspace and build alongside the model, together.
• MCP integration — so the agent can plug into your own tools and data sources.

Requires a local build of antirez's ds4 + DeepSeek V4 GGUF weights. Heads up — it's heavy: in 2-bit the "Flash" weights need ~96–128 GB RAM. The README has screenshots of every mode (chat, agent, the design pipeline, LAN) if you can't run it locally.

Repo (BSD-3): https://github.com/sk8erboi17/DStudio

Building in the open and early — would love feedback on the direction, especially the LAN/multi-device flow, the design pipeline, and what you'd want from Cowork / MCP. AMA.