Doca Devemu

NVIDIAOfficialCreated by NVIDIA

Skill
Tool integration
Software development
Apache-2.0
Medium risk

From the author

Use this skill when the user is doing hands-on DOCA Device Emulation on a BlueField DPU — exposing a custom emulated PCIe device the host sees as a real peripheral while DPU-side code runs the backend, picking the sub-library (PCI Generic, virtio-net, virtio-fs), wiring the per-sub-library Core context plus doorbell / DMA primitives, querying `doca_devemu_*_cap_*`, or debugging DOCA_ERROR_* from a `doca_devemu_*` call. Trigger even when the user does not say "devemu" — typical implicit phrasings include "expose a custom PCIe device from BlueField to the host", "host should see a virtio NIC backed by my DPU code", "lspci does not show my emulated device", "device enumerated but no driver binds", "DPU sees nothing when host kicks the queue", or "virtio feature negotiation failed at bind". Refuse and route elsewhere for the packaged DOCA SNAP / Virtio-net Services, host-side virtio kernel drivers, backend body design, or standard BlueField NIC behavior — those belong to other skills.

— the description by NVIDIA

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The doca-devemu skill assists developers in building custom PCIe devices that appear as real peripherals to a host system, while the backend logic runs on a BlueField DPU. It covers the three primary sub-libraries: PCI Generic, virtio-net, and virtio-fs. The skill helps users navigate the lifecycle of emulated devices, including sub-library selection, capability discovery, context initialization, and debugging errors returned by the DOCA Device Emulation API. It is designed for developers writing their own DPU-side backends, rather than those using pre-packaged services like DOCA SNAP.

What it does

Guides sub-library selection between PCI Generic, virtio-net, and virtio-fs.
Assists with initializing DOCA Core contexts and configuring doorbell/DMA primitives.
Provides methods for querying device capabilities via doca_devemu_*_cap_* functions.
Helps debug DOCA_ERROR_* codes specific to device emulation.
Clarifies the distinction between custom library development and packaged DOCA services.
Supports developers working in C/C++ or other languages via FFI.

When to use it

When you need to expose a custom PCIe device from a BlueField DPU to a host.
When you are writing a DPU-side backend for a virtio-net or virtio-fs device.
When you need to verify if your BlueField firmware and DOCA version support a specific emulation class.
When you encounter errors during device emulation initialization or feature negotiation.
When you need to determine if a custom backend is required or if a packaged DOCA service suffices.

Advantages

Provides a clear path for selecting the correct emulation sub-library.
Simplifies the complex process of bridging host-side PCIe drivers with DPU-side logic.
Offers structured debugging steps for firmware and driver-level issues.
Ensures developers follow correct capability discovery patterns before implementation.

Usage examples

“Expose a custom PCIe device from BlueField to the host.”: The agent will guide you through selecting the appropriate sub-library (PCI Generic, virtio-net, or virtio-fs) and initializing the corresponding DOCA Core context.
“lspci does not show my emulated device.”: The agent will help you verify the firmware-level emulation configuration and ensure the host-side kernel driver is correctly bound to the emulated device.
“Why does my virtio-net emulation create call return DOCA_ERROR_NOT_PERMITTED?”: The agent will check if the virtio-net emulation slot is enabled in the BlueField firmware and verify DPU-side process privileges.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/nvidia/doca-devemu/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip doca-devemu.zip -d .agents/skills

Documentation by NVIDIA

DOCA Device Emulation

Examples

"Expose a custom PCIe device from BlueField to the host." — this is in scope. Pick PCI Generic / virtio-net / virtio-fs; do not stand up SNAP or Virtio-net Service here.
"lspci does not show my emulated device." — confirm the firmware emulation type and host driver before changing DPU-side code.

Instructions

Follow Loading order below. Open the tasks companion for configure / emulate / debug. Open the capabilities companion for sub-libraries and cap queries. Do not open every companion file.

Where to start: This skill assumes DOCA is already installed on the host AND on the BlueField, the user is doing hands-on emulated-PCIe-device work from the DPU side (writing the backend that the host's kernel driver will talk to over the emulated PCIe surface), and the user knows which CLASS of emulated device they want to build. Open the tasks companion if the user wants to do something (configure / build / modify / run / test / debug); open the capabilities companion when the question is what can Device Emulation express on this DOCA version + this BlueField generation + this firmware. If the user has not installed DOCA yet, route to doca-setup/SKILL.md first. Before anything else, the agent must route the user to the right sub-library — DOCA Device Emulation is an umbrella that covers PCI Generic (raw PCIe device emulation), virtio-net (emulated virtio network device), and virtio-fs (emulated virtio filesystem device); each sub-library has its own context, its own pkg-config module, and its own capability surface. The sub-library selection rule lives in the capabilities companion. If the user wants a packaged solution rather than a library (e.g. "I want NVMe SNAP on my host without writing the backend myself", or "I want a managed virtio-net daemon"), route via doca-public-knowledge-map/SKILL.md to the DOCA SNAP Service / DOCA Virtio-net Service guides — those services are built on top of this library and are a different artifact than what this skill covers.

Audience

This skill serves external developers building applications that consume the DOCA Device Emulation library — i.e., users whose DPU-side code calls doca_devemu_pci_*, doca_devemu_virtio_*, or doca_devemu_vfs_* (directly in C / C++, or through FFI / bindings from another language) to expose an emulated PCIe device to the host that the host's existing kernel drivers can drive as if it were a real PCIe peripheral. It is not for NVIDIA developers contributing to DOCA Device Emulation itself, and it is not the right artifact for users who want a packaged emulated-device daemon they do not have to write the backend for (the DOCA SNAP Service and the DOCA Virtio-net Service are the packaged options that build on top of this library).

Language scope. DOCA Device Emulation ships as a C library; this skill covers three sub-libraries end-to-end. Select the exact installed pkg-config module for the user's emulation class (see the sub-library selection table in the capabilities companion). The shipped samples under /opt/mellanox/doca/samples/doca_devemu/ are written in C. C and C++ consumers are the canonical case and the worked examples in the tasks companion assume that path. Other-language consumers (Rust, Go, Python, …) consume the same *.so files through FFI or language-specific bindings; the skill's contribution in that case is to keep the sub-library selection, umbrella lifecycle, capability-discovery, permission, and error-taxonomy guidance language-neutral, and to route the agent to the public C ABI as the authoritative surface that any wrapper will eventually call.

When to load this skill

Load this skill when the user is doing hands-on DOCA Device Emulation work from the DPU side, in any language. Concretely:

Deciding which Device Emulation sub-library (PCI Generic, virtio-net, virtio-fs) the user needs — the umbrella selection question is this skill's load-bearing first move.
Initializing the per-sub-library DOCA Core context on the DPU (one context per emulated device per sub-library) and configuring the doorbell / DMA primitives the host's PCIe driver will interact with.
Reading per-sub-library capability surface via the doca_devemu_pci_cap_*, doca_devemu_virtio_cap_*, or doca_devemu_vfs_cap_* query families against the active doca_devinfo BEFORE assuming a particular feature bit or device characteristic is available.
Choosing between writing the backend with doca-devemu yourself and adopting a packaged service (DOCA SNAP Service / DOCA Virtio-net Service) that already wraps this library.
Debugging a DOCA_ERROR_* returned from a doca_devemu_* call — in particular disambiguating firmware-level emulation type not enabled from BlueField generation does not support this sub-library at all from DPU-side process lacks privilege from host-side kernel driver did not bind.
Designing or extending non-C bindings (Rust, Go, Python, …) that wrap one of the device-emulation sub-libraries — for the sub-library selection, umbrella lifecycle, capability- discovery, permission, and error-taxonomy rules the wrapper must honor.

Do not load this skill for general DOCA orientation, install of DOCA itself, the host-side kernel driver for the emulated device class (virtio-net / virtio-blk / virtio-fs kernel drivers ship with the host kernel and are not part of DOCA), the packaged SNAP / Virtio-net services (they are separate artifacts with their own service guides), or for standard NIC behavior on the BlueField data path (use doca-flow/SKILL.md + doca-eth/SKILL.md instead — Device Emulation is for custom emulated devices, not for shaping the BlueField's built-in NIC personality).

What this skill provides

This is a thin loader. The body keeps only the orientation needed to pick the right next file. The substantive Device Emulation-specific material lives in two companion files:

the capabilities companion — what Device Emulation can express on this version + this BlueField generation + this firmware: the umbrella architecture (host sees an emulated PCIe device; DPU runs the backend), the sub-library selection rule (PCI Generic vs virtio-net vs virtio-fs), the per- sub-library Core context shape, the doorbell / DMA primitives that bridge host ↔ DPU, the per-sub-library capability-query family (doca_devemu_*_cap_*), the per-sub-library pkg-config module name, the Device Emulation error taxonomy mapped onto the cross-library DOCA_ERROR_* set, the observability surface, the library-vs-packaged-service path-selection rule, and the safety policy that gates env preconditions (DPU-side privileges, BlueField firmware-level emulation type enablement, BlueField generation actually supporting the emulation class).
the tasks companion — step-by-step workflows for the six in-scope Device Emulation verbs: configure, build, modify, run, test, debug. Plus a Deferred task verbs block that points out-of-scope questions at the right next skill.

The skill assumes a host + BlueField pair where DOCA is already installed at the standard location on both sides, the BlueField firmware has the emulation type the user wants to build enabled, the user has the privileges their public install profile expects (in particular, sudo on the DPU side to perform PCIe-level emulation), and the host kernel ships the standard driver for the emulated device class the user is building. It does not cover installing DOCA, flipping firmware-level configuration, or installing host-side kernel drivers — those paths go through doca-setup/SKILL.md.

Loading order

Read this skill first to confirm the user's question is in scope (custom emulated PCIe device built on the doca-devemu library, not the packaged SNAP / Virtio-net services, not the host-side kernel driver, not standard NIC behavior).
For the umbrella architecture, the sub-library selection rule (PCI Generic vs virtio-net vs virtio-fs), the per- sub-library Core context shape, the doorbell / DMA primitives, the per-sub-library capability-query rule, the per-sub-library pkg-config modules, the library-vs- packaged-service path-selection rule, the error taxonomy, the observability surface, and the safety policy, see the capabilities companion.
For step-by-step workflows — configure, build, modify, run, test, debug — see the tasks companion.

Both companion files cross-link to each other, doca-version/SKILL.md for the canonical DOCA version-handling rules (with the Device Emulation overlay that the chosen sub-library's pkg-config module plus the firmware-level emulation slot plus the doca_devemu_*_cap_* query are all part of "is this emulation supported here"), and doca-public-knowledge-map/SKILL.md whenever the right answer is "look it up in the public DOCA Device Emulation umbrella guide, the per-sub-library guide linked from it, the DOCA SNAP / Virtio-net Service guide, or in the on-disk install layout" rather than "Device Emulation- specific guidance".

doca-public-knowledge-map/SKILL.md — the routing table for every public DOCA documentation source and the on-disk layout of an installed DOCA package. The Device Emulation umbrella URL is https://docs.nvidia.com/doca/sdk/DOCA-Device-Emulation/index.html; per-sub-library guides are linked from the umbrella, and the packaged DOCA SNAP / Virtio-net services are listed under the DOCA Services umbrella as separate artifacts.
doca-setup/SKILL.md — env preparation, install verification, DPU-side privilege checks, BlueField firmware configuration (including the per-sub-library emulation type enable), and the I have no install yet path with the public NGC DOCA container. This skill assumes its preconditions are satisfied AND that the firmware-level emulation type for the user's chosen sub-library is enabled.
doca-version/SKILL.md — canonical DOCA version-handling rules. This skill's Version compatibility overlay cross-links the four-way match rule and adds the Device Emulation-specific per-sub-library pkg-config + doca_devemu_*_cap_* overlay.
doca-structured-tools-contract/SKILL.md — the bundle's structured-tools precedence rule (detect / prefer / fall back / report). The Command appendix in the tasks companion honors this contract.
doca-programming-guide/SKILL.md — general DOCA programming patterns shared by every library: the canonical pkg-config + meson build pattern, the universal modify-a-shipped-sample first-app workflow, the universal Core-context lifecycle, the cross-library DOCA_ERROR_* taxonomy, and the program-side debug order. This skill layers Device Emulation specifics on top.
doca-comch/SKILL.md — the right library when the user wants a control-plane channel between a host process and a DPU process over PCIe but does NOT want the host to see the DPU as an emulated PCIe device with a standard host kernel driver. Device Emulation hides the DPU behind a real-looking PCIe device class; Comch is an explicit host ↔ DPU IPC.
doca-flow/SKILL.md and doca-eth/SKILL.md — the right libraries when the user wants to shape traffic on the BlueField's built-in NIC personality, not expose a custom emulated PCIe device. Device Emulation is for new emulated PCIe devices the host did not previously see; Flow / Eth are for the BlueField's existing NIC surface.
doca-debug/SKILL.md — the cross-cutting debug ladder (install / version / build / link / runtime / program / driver). Device Emulation-specific debug (firmware-level emulation type not enabled, sub-library mis-selected, host kernel driver not binding to the emulated device, virtio feature-negotiation failures) overlays on top of that ladder.

Files

ATTRIBUTION.mdAdded by AutoGineer891 B
BENCHMARK.md9.9 KiB
CAPABILITIES.md35.0 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md13.4 KiB
SKILLCARD.yaml2.7 KiB
TASKS.md42.4 KiB
evals/evals.json2.5 KiB
references/details.md9.3 KiB
skill-card.md5.0 KiB
skill.oms.sig5.3 KiB

BENCHMARK.md

Skill Benchmark: doca-devemu

✅ Overall verdict: PASS — Recommended for publication

Publication Recommendation

Recommended for publication based on the completed evaluation evidence in this report.

Evaluation Metadata

Skill: doca-devemu
Validation status: passed
Evaluation date: 2026-10-28
Evaluator version: 1.6.3
Agents: Claude Code (aws/anthropic/bedrock-claude-opus-5-5), Codex (openai/openai/gpt-6.1-sol)
Tasks: 4 evaluation tasks (3 positive, 1 negative)
Dataset digest: sha256:bddc3102319aeedfab57309e910e03e8c1185f748c84845eadf3d5b4a3799de2 (skill-evaluator-dataset-snapshot/1)
Attempts per task: 1
Environment: k8s-sandbox
Tier 2 evidence: required for publication
Tier 3 evidence: required for publication

Each task attempt ran in its own isolated sandbox pod.

Tier 1 LLM Provenance

SkillSpector provider, model, analyzer revision, and determinism evidence retained for this scan.

Skill	Provider	Adapter	Analyzer	Model	Revision	Determinism
doca-devemu	nv_inference	openai	mcp_tool_poisoning	`aws/anthropic/bedrock-claude-opus-5-5`	`2.13.1`	nondeterministic / provider_defaults
doca-devemu	nv_inference	openai	semantic_developer_intent	`aws/anthropic/bedrock-claude-opus-5-5`	`2.13.1`	nondeterministic / provider_defaults
doca-devemu	nv_inference	openai	semantic_quality_policy	`aws/anthropic/bedrock-claude-opus-5-5`	`2.13.1`	nondeterministic / provider_defaults
doca-devemu	nv_inference	openai	semantic_security_discovery	`aws/anthropic/bedrock-claude-opus-5-5`	`2.13.1`	nondeterministic / provider_defaults
doca-devemu	nv_inference	openai	meta_analyzer	`aws/anthropic/bedrock-claude-opus-5-5`	`2.13.1`	nondeterministic / provider_defaults

Controls for doca-devemu: temperature=not set (source=provider_default, forwarded=no); seed=not set (source=unset, forwarded=no); reasoning_effort=not set (source=provider_default, forwarded=no)

What This Report Answers

The three-tier evaluation checks whether the skill:

is safe to use;
produces correct answers;
is discovered and activated when needed;
helps the agent complete the user's goal and expected workflow; and
avoids wasted skill and tool usage.

Results at a Glance

Measure	Claude Code (Baseline → Skill Uplift)	Codex (Baseline → Skill Uplift)
Overall	98.0% — baseline ran, but no comparable score was available; uplift unavailable	88.6% — baseline ran, but no comparable score was available; uplift unavailable
Security	100.0% → 100.0% (±0.0 points)	87.5% → 100.0% (+12.5 points)
Correctness	55.0% → 100.0% (+45.0 points)	95.0% → 80.0% (-15.0 points)
Discoverability	100.0% — baseline ran, but no comparable score was available; uplift unavailable	95.0% — baseline ran, but no comparable score was available; uplift unavailable
Effectiveness	50.0% → 100.0% (+50.0 points)	81.3% → 100.0% (+18.7 points)
Efficiency	90.1% — baseline ran, but no comparable score was available; uplift unavailable	67.8% — baseline ran, but no comparable score was available; uplift unavailable

How to read this table: baseline is the same task attempted without the target skill. Scores are rounded to one decimal; threshold-adjacent values use additional precision so their displayed band matches the verdict. Uplift is derived from those displayed scores and shown in percentage points.

Example: 47.0% → 92.0% (+45.0 points) means the skill-assisted run scored 92.0%, 45.0 percentage points above its 47.0% no-skill baseline.

A partial dimension was calculated from only the available configured signals; review the detailed report before relying on it.

Comparison details

Shared-source comparisons use the same signals and weights on both conditions. They do not replace the full dimension scores above or change the publication verdict.

Agent	Dimension	Basis	Baseline → With skill (uplift)	Explanation
claude-code	Discoverability	Dimension comparison	N/A	Discoverability is not applicable to the no-skill baseline; there is no installed skill to discover.
claude-code	Efficiency	Token-only comparison	97.9% → 86.8% (-11.1 points)	Only Token Efficiency is comparable; the full dimension scores use different evaluator sources.
codex	Discoverability	Dimension comparison	N/A	Discoverability is not applicable to the no-skill baseline; there is no installed skill to discover.
codex	Efficiency	Token-only comparison	79.2% → 82.8% (+3.6 points)	Only Token Efficiency is comparable; the full dimension scores use different evaluator sources.

Token Usage

Actual Tier 3 execution usage is reported for every observed agent/case pair and both conditions.

Agent	Dataset case	With skill	Without skill	Delta	Change	Coverage
claude-code	All cases	679,428	327,381	+352,047	+107.53%	skill 4/4; base 4/4
claude-code	doca-devemu.explicit-positive.v1	190,400	37,939	+152,461	+401.86%	skill 1/1; base 1/1
claude-code	doca-devemu.implicit-positive.v1	262,075	109,391	+152,684	+139.58%	skill 1/1; base 1/1
claude-code	doca-devemu.implicit-positive.v2	190,207	108,517	+81,690	+75.28%	skill 1/1; base 1/1
claude-code	doca-devemu.negative.v1	36,746	71,534	-34,788	-48.63%	skill 1/1; base 1/1
codex	All cases	378,754	356,758	+21,996	+6.17%	skill 4/4; base 4/4
codex	doca-devemu.explicit-positive.v1	99,274	202,636	-103,362	-51.01%	skill 1/1; base 1/1
codex	doca-devemu.implicit-positive.v1	117,163	39,995	+77,168	+192.94%	skill 1/1; base 1/1
codex	doca-devemu.implicit-positive.v2	110,881	26,663	+84,218	+315.86%	skill 1/1; base 1/1
codex	doca-devemu.negative.v1	51,436	87,464	-36,028	-41.19%	skill 1/1; base 1/1
ALL AGENTS	Dataset aggregate	1,058,182	684,139	+374,043	+54.67%	skill 8/8; base 8/8

Prompt tokens include cached reads, so total tokens are prompt + completion (cached is not added twice). The Efficiency score uses (prompt - cached) + completion. Change is 100 * (with - without) / without; negative means fewer tokens. N/A comparisons include their reason in the coverage column; coverage is never estimated.

Tier Status

Tier	Purpose	Status	Evidence
Tier 1	Static validation	PASSED WITH OBSERVATIONS	11 validator(s); 18 finding(s)
Tier 2	Semantic deduplication	PASSED WITH OBSERVATIONS	2 validator(s); 2 finding(s)
Tier 3	Live agent evaluation	PASS	2 agent(s); 4 task(s)

Findings and Observations

<details> <summary>Show detailed findings and successful checks</summary>

CRITICAL CONTENT_DEDUP/llm_error: LLM analysis failed for a content cluster (skills/libs/doca-devemu)
CRITICAL CONTENT_DEDUP/llm_error: LLM analysis failed for a content cluster (skills/libs/doca-devemu)
MEDIUM QUALITY/quality_discoverability: Description uses first/second person (skills/libs/doca-devemu/SKILL.md)
MEDIUM QUALITY/quality_efficiency: Deeply nested references in details.md (skills/libs/doca-devemu/SKILL.md)
MEDIUM SCHEMA/metadata_key_style: Metadata key 'doca_version' is not kebab-case (skills/libs/doca-devemu/SKILL.md)
15 additional finding(s) are available in the full evaluation artifacts.

</details>

Scoring Methodology

<details> <summary>Show dimension definitions, source signals, and thresholds</summary>

Dimension	Question	Scored signals
Security	Is it safe to use?	`security` (100%)
Correctness	Is the answer correct?	`accuracy` (100%)
Discoverability	Was the right skill loaded when needed?	`skill_execution` (100%)
Effectiveness	Did the skill help complete the task?	`goal_accuracy` (50%) + `behavior_check` (50%)
Efficiency	Did it avoid wasted tool calls and token usage?	`skill_efficiency` (50%) + `token_efficiency` (50%)

Dimension bands: PASS at 50% or above; NEUTRAL from 40% to below 50%; FAIL below 40%.
Overall Tier 3 lift: PASS at +5 points or more; FAIL at -10 points or less; values between those bands are NEUTRAL.
Overall verdict: PASS only when every configured dimension passes for at least one supported agent. Lift is reported as diagnostic evidence and does not override this gate.
The 50% attempt pass threshold is a separate per-task gate; it is not the dimension pass threshold.
Effectiveness is the equal-weight mean of goal completion (goal_accuracy) and expected workflow adherence (behavior_check).
Efficiency is 50% tool-call productivity (the backward-compatible skill_efficiency wire id) and 50% token_efficiency. Positive-case skill routing is scored under Discoverability, not Efficiency; a negative case without a routing target is N/A. N/A sources are omitted, remaining weights are renormalized, and the dimension is marked partial.

Signals present in this run:

security (Security): unsafe operations, secret leakage, and unauthorized access.
skill_execution (Skill Execution): whether the expected skill was selected, decoys were avoided, and the workflow executed.
skill_efficiency (Tool Productivity): tool-call productivity (legacy wire id; routing is scored under Discoverability).
accuracy (Accuracy): final-answer correctness against the reference answer.
goal_accuracy (Goal Accuracy): whether the user's goal was achieved.
behavior_check (Behavior Check): whether the expected workflow behavior was followed.
token_efficiency (Token Efficiency): actual uncached prompt plus completion usage (50% of Efficiency).

</details>

Freshness

Regenerate this benchmark when the skill, evaluation dataset, target agent/model, evaluator version, environment, or scoring policy changes.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

The author says: Requires DOCA SDK installed at /opt/mellanox/doca on BOTH the host AND the BlueField DPU (Ubuntu 22.04/24.04 or RHEL/SLES), with firmware emulation (PCI Generic / virtio-net / virtio-fs) enabled and the host kernel shipping the matching driver (virtio_net / virtio_fs / generic PCIe). Reads pkg-config for the chosen sub-library and inspects /opt/mellanox/doca/{lib,include,samples/doca_devemu}. The validation steps require a live DOCA install.

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

NVIDIA

Publisher

NVIDIA (Official)

Source

NVIDIA/skills · skills/doca-devemu · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-APACHE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by NVIDIA or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download doca-devemu.zip