codesnips
rust 13 lines · 1 tab

Inline assembly for critical performance hotspots

Marcus Chen Jan 2026
1 tab 
#![feature(asm)]

fn add_asm(a: u64, b: u64) -> u64 {
    let result: u64;
    unsafe {
        asm!(
            "add {0}, {1}",
            inlateout(reg) a => result,
            in(reg) b,
        );
    }
    result
}
1 file · rust Explain with highlit

Rust's inline assembly (asm! macro) lets you write assembly for performance-critical code or to access hardware features. It's an unstable feature (nightly only) and requires unsafe. I use it sparingly for SIMD intrinsics not exposed by std::arch, cryptography, or tight loops where the compiler can't optimize well. The syntax is similar to GCC's inline assembly. You specify inputs, outputs, and clobbers. For most cases, Rust's abstractions are fast enough, but inline assembly is the escape hatch when you need it. Always benchmark before resorting to assembly, and document why it's necessary. It sacrifices portability and readability for performance.

Related snips

rust 
struct Config<'a> {
    name: &'a str,
    value: &'a str,
}

fn parse_config(line: &str) -> Config {

Lifetime annotations for flexible borrowing in structs

rust lifetimes borrowing
by Marcus Chen 1 tab
ruby 
require "csv"

class PeopleCsvStream
  include Enumerable

  HEADERS = %w[id full_name email signed_up_at plan].freeze

Resilient CSV Export as a Streamed Response

rails performance streaming
by codesnips 3 tabs
rust 
use crossbeam::channel::unbounded;
use std::thread;

fn main() {
    let (tx, rx) = unbounded();

Crossbeam for advanced concurrent data structures

rust concurrency lock-free
by Marcus Chen 1 tab
ruby 
Rails.application.configure do
  config.after_initialize do
    Bullet.enable = true
    Bullet.alert = false
    Bullet.bullet_logger = true
    Bullet.console = true

N+1 query detection with Bullet gem

rails performance activerecord
by Alex Kumar 2 tabs
rust 
use tracing::{info, instrument};

#[instrument]
fn process_request(user_id: u64) {
    info!(user_id, "Processing request");
    // Work happens here

tracing for structured logging and distributed tracing

rust observability tracing
by Marcus Chen 1 tab
rust 
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

Channels (mpsc) for message passing between threads

rust concurrency channels
by Marcus Chen 1 tab

Share this code

Here's the card — post it anywhere.

Inline assembly for critical performance hotspots — share card
Link copied