awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
janestreet avatar

janestreet/magic-trace

0
View on GitHub↗
magic-trace.org↗

Magic Trace

magic-trace collects and displays high-resolution traces of what a process is doing

Features

  • Intel Processor Trace Captures - Records every function call by decoding compressed control-flow packets from Intel CPU hardware at nanosecond granularity.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • Multi-Language Symbol Resolvers - Resolves function names across OCaml, C, C++, Rust, and Python using debug symbols and JIT perf maps.
  • Call Stack Timelines - Provides an interactive timeline viewer for exploring recorded call stacks with zoom, pan, and measurement tools.
  • Performance Profiling - Reveals function-level execution details invisible to sampling profilers for precise bottleneck identification.
  • Trace Ring Buffer Snapshots - Maintains a circular buffer of trace data frozen on a trigger event to capture execution history leading up to that moment.
  • Intel Processor Trace Profilers - Provides nanosecond-granularity execution traces using Intel Processor Trace hardware for performance diagnosis.
  • Program Execution Tracing - Displays a full zoomable trace of all function calls to show program behavior during execution windows.
  • Trace Snapshot Capturers - Captures high-resolution snapshots of program execution using Intel Processor Trace at nanosecond granularity.
  • Ring Buffer Control-Flow Snapshots - Records every function call into a ring buffer and snapshots it on trigger for interactive timeline analysis.
  • Full Function Call Recorders - Records every function call made by a process using Intel Processor Trace hardware for complete execution histories.
  • Intel Processor Trace Execution Tracers - Captures every function call a process makes using Intel Processor Trace to diagnose sub-microsecond performance issues.
  • Running Process Tracers - Attaches to running Linux processes to capture high-resolution traces of every function call using Intel Processor Trace.
  • Function-Call Triggered Snapshots - Snapshots the control-flow ring buffer when a specified function is called or on manual interrupt for targeted analysis.
  • Function-Level Execution Diagnosis - Revealing function-level execution details invisible to sampling profilers for precise identification of slow code paths.
  • Hardware-Assisted Function Traces - Provides nanosecond-resolution function call traces using Intel Processor Trace hardware for performance diagnosis.
  • Execution Trace Visualizers - Ships an interactive web-based timeline viewer for exploring captured execution traces with zoom and measurement.
  • Manual Interrupt Trace Triggers - Snapshots the control-flow ring buffer on Ctrl+C to capture program state at an arbitrary moment.
  • Interactive Trace Viewers - Ships a web-based interactive timeline viewer with zoom, pan, measurement, and annotation tools for trace exploration.
  • Multi-Backend Callstack Reconstructors - Rebuilds callstacks from sampled data using LBR, DWARF, or frame pointers with different depth and compatibility trade-offs.
  • Trace Timer Resolution Adjusters - Reduce memory bandwidth consumption of Intel PT tracing by lowering the timing resolution to decrease overall performance overhead.
  • Multi-Backend Callstack Reconstructors - Rebuilds call stacks from sampled data using LBR, DWARF, or frame pointers with different depth and compatibility trade-offs.
  • Multi-Language Trace Resolvers - Traces function calls across OCaml, C, C++, Rust, and Python in mixed-language programs.
  • Execution Event Correlation - Records architectural event counts alongside execution traces to correlate code paths with CPU events.
  • Call Stack Samplers - Periodically captures call stack snapshots to build statistical profiles of where a program spends its time.
  • Multi-Language Execution Tracers - Traces function calls across OCaml, C, C++, Rust, and Python in mixed-language programs.
  • Process Attachment Tools - Attaches to an already-running process and captures its execution trace without restarting it.
  • Hardware Event Samplers - Captures sampled hardware events like branch and cache misses and displays them as separate tracks in the trace.
  • Sampling Callstack Tracers - Captures callstacks at intervals using sampling as an alternative to Intel Processor Trace for machines without PT support.
  • Triggered Function Snapshots - Snapshots the control-flow ring buffer when a user-specified function is called for targeted code path analysis.
  • Post-Request Completion Snapshots - Interrupt the application for approximately 10 microseconds only after a user request is fully serviced, preventing snapshot overhead from affecting end-user experience.
  • Interactive Timeline Visualizations - Serves captured traces as an interactive HTML timeline in the browser with zoom, pan, measurement, and annotation tools.
  • 6,108 stars·195 forks·OCaml·MIT·14 views

    Star history

    Star history chart for janestreet/magic-traceStar history chart for janestreet/magic-trace

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does janestreet/magic-trace do?

    magic-trace collects and displays high-resolution traces of what a process is doing

    What are the main features of janestreet/magic-trace?

    The main features of janestreet/magic-trace are: Intel Processor Trace Captures, Multi-Language Symbol Resolvers, Call Stack Timelines, Performance Profiling, Trace Ring Buffer Snapshots, Intel Processor Trace Profilers, Program Execution Tracing, Trace Snapshot Capturers.

    Which projects share features with janestreet/magic-trace?

    Projects with overlapping indexed features include: gaogaotiantian/viztracer — VizTracer is a Python runtime instrumentation system and execution profiler used to trace and visualize code… mstange/samply — Samply is a cross-platform CPU sampling profiler and performance analysis utility. It consists of a command-line tool… binaryanalysisplatform/qira — Qira is a binary analysis platform and execution tracer that records every instruction and data access during program… jlfwong/speedscope — Speedscope is a web-based performance profiler that visualizes profiling data through interactive flamegraphs and… garbles/why-did-you-update — why-did-you-update is a React development tool and performance profiler designed to identify unnecessary component… jbachorik/btrace — btrace is a Java dynamic tracing tool and instrumentation framework designed for real-time diagnostics. It enables the…

    Projects sharing features with Magic Trace

    These projects share indexed features with Magic Trace. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • gaogaotiantian/viztracergaogaotiantian avatar

      gaogaotiantian/viztracer

      7,674View on GitHub↗

      VizTracer is a Python runtime instrumentation system and execution profiler used to trace and visualize code execution. It functions as a multi-process performance analyzer and trace visualizer, providing an interactive timeline and flamegraph interface to identify performance bottlenecks and analyze call sequences. The project distinguishes itself by its ability to aggregate execution data from multiple threads, subprocesses, and asynchronous tasks into a single unified report. It also features live process instrumentation, allowing users to attach to and detach from running Python applicati

      Pythondebuggingflamegraphlogging
      View on GitHub↗7,674
    • binaryanalysisplatform/qiraBinaryAnalysisPlatform avatar

      BinaryAnalysisPlatform/qira

      4,071View on GitHub↗

      Qira is a binary analysis platform and execution tracer that records every instruction and data access during program execution for interactive playback and debugging. It functions as a runtime analysis environment that uses QEMU to trace execution and inspect memory and register states. The system provides a binary static analysis tool that maps program structure and annotates instructions based on captured runtime data. It includes a runtime memory analyzer to monitor reads and writes to specific addresses and an interactive debugger for navigating execution timelines. The platform covers

      C
      View on GitHub↗4,071
    • mstange/samplymstange avatar

      mstange/samply

      4,263View on GitHub↗

      Samply is a cross-platform CPU sampling profiler and performance analysis utility. It consists of a command-line tool for recording process stack traces at regular intervals and a visual interface for analyzing the resulting execution data. The system includes a debug symbol resolver that maps raw memory addresses to human-readable function names using local or remote symbol information. It transforms recorded execution data into flame graphs and timelines to pinpoint function-level hotspots. The tool provides capabilities for CPU execution recording, stack unwinding, and symbol resolution a

      Rust
      View on GitHub↗4,263
  • garbles/why-did-you-updategarbles avatar

    garbles/why-did-you-update

    4,930View on GitHub↗

    why-did-you-update is a React development tool and performance profiler designed to identify unnecessary component re-renders. It functions as a render debugger that logs the specific prop and state changes triggering updates to the developer console. The utility focuses on React performance optimization by detecting wasteful update cycles. It provides diagnostic logging to highlight why a component updated, helping to reduce redundant user interface cycles. The tool covers frontend performance profiling through the use of higher-order component wrappers, state snapshot comparisons, and refe

    JavaScript
    View on GitHub↗4,930
  • Compare all 30 related projects→

    Curated searches featuring Magic Trace

    Hand-picked collections where Magic Trace appears.
    • Dynamic Instrumentation Hooking Frameworks