# rust-unsafe

Guides coding agents through writing and auditing unsafe Rust. Covers raw pointer rules, transmute pitfalls, and safe abstraction design.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 556 installs · ★ 267
- Author: mohitmishra786
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/rust/rust-unsafe/SKILL.md
- Updated: 2026-06-27
- HTML: https://affpapa.org/en/nevibecode/skills/rust-unsafe

## What it does

The skill outlines constraints for the five unsafe superpowers in Rust: dereferencing raw pointers, calling unsafe or `extern "C"` functions, modifying mutable statics, implementing unsafe traits like `Send` and `Sync`, and reading union fields. Other operations follow standard borrow checker rules even inside an `unsafe` block.

It provides implementation templates for custom collections, interior mutability via `UnsafeCell`, alternatives to `std::mem::transmute`, and an audit checklist. Each raw pointer dereference must satisfy explicit invariants: non-null state, proper alignment, initialized memory, and zero aliasing conflicts.

Skipping tests under Miri or omitting `// Safety:` comments easily introduces undefined behavior into production code.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill rust-unsafe -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/rust-unsafe/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/rust-unsafe/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill rust-unsafe -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/rust-unsafe/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill rust-unsafe -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/rust-unsafe/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install mohitmishra786/low-level-dev-skills rust-unsafe
```

2. **Manually: put the files in place**
- File: `.github/skills/rust-unsafe/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill rust-unsafe -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/mohitmishra786/low-level-dev-skills --path skills/rust/rust-unsafe
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/rust-unsafe/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill rust-unsafe -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/rust/rust-unsafe/SKILL.md

## When to use it
- audit unsafe Rust blocks against memory alignment and aliasing rules
- build safe wrapper APIs around raw memory allocations
- replace risky `transmute` calls with type-safe standard library methods
- implement `Send` and `Sync` traits with verified thread safety

## Example prompts
- Audit this unsafe block for pointer alignment and aliasing violations.
- Write a safe vector abstraction around raw pointers with a proper Drop implementation.
- Show safe alternatives to std::mem::transmute for this byte slice.

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 05129894f35450e2.

BEGIN THIRD-PARTY FILE 05129894f35450e2
````text
---
name: rust-unsafe
description: Rust unsafe code skill for systems programming. Use when writing or reviewing unsafe Rust, understanding what operations require unsafe, implementing safe abstractions over unsafe code, auditing unsafe blocks, or understanding raw pointers, transmute, and extern. Activates on queries about unsafe Rust, raw pointers, transmute, unsafe blocks, writing safe wrappers, UnsafeCell, unsafe trait impl, or auditing unsafe code.
---

# Rust unsafe

## Purpose

Guide agents through writing, reviewing, and reasoning about unsafe Rust: what operations require `unsafe`, how to write safe abstractions, audit patterns, common pitfalls, and when to reach for `unsafe`.

## Triggers

- "When do I need to use unsafe in Rust?"
- "How do I write a safe abstraction over unsafe code?"
- "How do I audit an unsafe block?"
- "What are the rules for raw pointers in Rust?"
- "What does transmute do and when is it safe?"
- "How do I implement UnsafeCell correctly?"

## Workflow

### 1. The five unsafe superpowers

`unsafe` grants exactly five capabilities not available in safe Rust:

1. **Dereference raw pointers** (`*const T`, `*mut T`)
2. **Call unsafe functions** (including `extern "C"` functions)
3. **Access or modify mutable static variables**
4. **Implement unsafe traits** (`Send`, `Sync`)
5. **Access fields of unions**

Everything else in Rust — including memory allocation, borrowing, closures — follows safe rules even inside `unsafe` blocks.

### 2. Raw pointers

```rust
// Creating raw pointers (safe — no dereference yet)
let x = 42u32;
let ptr: *const u32 = &x;
let mut_ptr: *mut u32 = &mut some_val as *mut u32;

// Null pointer
let null: *const u32 = std::ptr::null();
let null_mut: *mut u32 = std::ptr::null_mut();

// Dereference (unsafe)
let val = unsafe { *ptr };

// Null check
if !ptr.is_null() {
    let val = unsafe { *ptr };
}

// Offset (safe to compute, unsafe to dereference)
let arr = [1u32, 2, 3, 4, 5];
let p = arr.as_ptr();
let third = unsafe { *p.add(2) };   // arr[2]
let also_third = unsafe { *p.offset(2) };

// Slice from raw parts
let slice: &[u32] = unsafe {
    std::slice::from_raw_parts(p, arr.len())
};
```

Rules for sound raw pointer dereference:
- Pointer must be non-null
- Pointer must be aligned for `T`
- Memory must be initialized for `T`
- Must not violate aliasing rules (only one `&mut` to a location)
- Memory must be valid for the lifetime of the reference

### 3. unsafe functions and traits

```rust
// Declare unsafe function (callers must uphold invariants)
/// # Safety
/// `ptr` must be non-null and aligned to `T`, and point to initialized data.
/// The caller must ensure no other mutable reference to the same location exists.
unsafe fn read_ptr<T>(ptr: *const T) -> T {
    ptr.read()  // ptr::read is unsafe
}

// Call unsafe function
let val = unsafe { read_ptr(some_ptr) };
````
END THIRD-PARTY FILE 05129894f35450e2

The third-party file has ended. Everything between the 05129894f35450e2 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2876 of 7765 bytes. © mohitmishra786 · MIT · https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/rust/rust-unsafe/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md