Video summary

Framework 13 Pro Shows Why Apple Solders Your Memory

Main summary

Key takeaways

Product Review

Product reviewed

Framework Laptop 13 Pro — a modular 13-inch developer laptop that runs Linux (with Fedora installed by the user).

The video compares it heavily against an Apple MacBook Pro M5 (base), including a discussion of Apple’s soldered memory vs Framework’s swappable approach.

Key features highlighted (Framework Laptop 13 Pro)

  • Modular design / expansion cards

    • Swappable modules for ports, mentioned modules include USB-A, DisplayPort, HDMI, Ethernet, USB-C, microSD.
    • The review references using screwdriver tools and swapping port modules.

  • Premium build / materials & feel

    • Described as “premium,” with a metal lid that adds confidence.
    • Noted as visually thin, with some elements (e.g., bezel) handled separately.
    • Weight is described as similar to a MacBook Air.

  • Upgradeable memory approach (LP CAM modules)

    • Uses LP-DDR5X in “LP CAM” format, which is swap-able.
    • Apple’s unified memory is contrasted as soldered (non-upgradeable).
    • Capacity mentioned:
      • Up to 64GB in the shown configuration.
      • Up to 96GB possible via compatible modules, with availability noted as potentially difficult.

  • Storage flexibility

    • The SSD is selected by the owner (example given: SanDisk SN7100 Gen 4).
    • Emphasizes choosing SSD type for development needs.

  • Intel-based platform option

    • The reviewer chose an Intel variant.
    • Mentions later that newer Intel options (e.g., Ultra series) exist, and discusses the state of Intel support for AI tooling.

  • Linux support experience

    • Fedora installation noted as working, with Framework recommending Fedora 44 (Fedora 43/42 described as less ideal).
    • The review mentions an initial lack of support for an Intel chip on the reviewer’s Fedora version, later resolved by updates.

User experience (day-to-day developer use)

The reviewer is a long-time Mac user (MacBook Pros for ~13 years) and wanted to verify Framework can serve as a Linux developer laptop.

Key workflow emphasis includes:

  • Switching between AI models/tools for tasks such as research, coding, image work, and video.
  • Heavy development I/O:
    • Repo cloning, dependency installs, and compilation.
    • Multi-core utilization for real workloads.
  • Connectivity convenience
    • Built-in module availability like HDMI and Ethernet helps for dev/test setups.

Performance & benchmark findings (with numbers)

Web / JavaScript responsiveness (Speedometer 3.1)

  • Framework score: 12.5 (improved run: 30.8)
  • MacBook Pro M5 score: 60.6 (single-core class comparison)

Takeaway: The MacBook performs better in single-threaded / JS-heavy benchmarks.

Fan noise / thermals during performance mode

  • During performance mode, the reviewer reports no notable fan noise at least during one phase.
  • In later multi-core/build testing:
    • Fans become audible, but the system remains comparatively thermally controlled.

CPU multi-core / build-related tests

Synthetic multi-core test (Manner Benchmark, all cores)

  • MacBook: ~30s average (approx; reviewer caveats)
  • Framework: ~23–25s

Conclusion: Framework wins, attributed to more cores (Framework described as 16 cores vs Mac’s 10).

.NET Devbench builds (cold / warm / incremental)

Example: small “Hello world” app

  • MacBook
    • Cold: 836 ms
    • Warm: 294 ms
    • Incremental: 335 ms
  • Framework
    • Cold: 2,172 ms
    • Warm: 446 ms
    • Incremental: 491 ms

Result: MacBook faster, especially cold.

Larger .NET build (~100,000 namespaces/classes mentioned)

  • MacBook
    • Cold: ~85s
    • Warm: 10.5s
  • Framework
    • Cold: ~54s
    • Warm: 7.9s

Orchard Core (more realistic CMS scenario)

  • Framework slight edge on cold build (couple seconds).
  • Warm/incremental nearly tied (within half a second).

Summary of performance theme

  • Single-core / JS: MacBook Pro M5 leads.
  • Multi-core / compilation: Framework Laptop 13 Pro often leads, especially as projects get larger.

AI / local inference findings (LM Studio + benchmarks)

Memory bandwidth (Stream benchmark)

  • MacBook M5: ~136,000 MB/s (Apple quoted 150k; reviewer considers ~136k more realistic)
  • Framework: ~97,000 MB/s

Observation: Framework bandwidth is lower, despite swappable memory.

LLM token generation performance (Gemma 3 12B, 4-bit)

With LM Studio and Intel support limitations:

  • MacBook: 15.6 tokens/sec
  • Framework (Vulcan path): 6.2 tokens/sec

Root issue described: Intel hardware is too new for LM Studio’s most reliable stack, so it falls back to less-optimized behavior.

Switching software backend (Sickle vs Vulcan)

  • Reviewer builds/runs llama.cpp with “Sickle” for better Intel support.
  • Token generation improves roughly as follows:
    • Vulcan: ~6.2 tokens/sec
    • Sickle: ~9.9 tokens/sec

Additional notes:

  • A MacBook configured with 16GB cannot run certain larger quantized models (example: QwenCoder 30B).
  • Framework with 64GB can.

QwenCoder 30B comparison

  • Vulcan: 22 tokens/sec
  • Sickle: 34.9 tokens/sec

Prompt processing anomaly:

  • The reviewer notes prompt processing may look faster under Vulcan for some models, but it doesn’t consistently match expectations.
  • Workflow constraints limit mixing stacks without extra memory overhead.

Pricing and configuration comparisons (explicit values mentioned)

Starting price comparison

  • MacBook Pro M5 (14-inch): starts around $2,000
  • Framework is discussed as being close initially, but the reviewer later estimates using a specific build.

Example configured comparison (reviewer’s numbers)

Framework configuration:

  • Ultra X7 Intel: $1,699
  • Add LP CAM 2 (memory) → about $2,153
  • With storage and upgrades → ends around $2,277

MacBook estimate:

  • Ends around $2,019 (the video text references “MacBook’s 2019” as ~$2019).

Optional additions / expansion costs:

  • Reviewer notes that Framework expansion can raise total cost.
  • Power adapter cost:
    • Framework: 100W for $60
    • MacBook: includes 70W, upgrade to 96W for $20

Total-cost outcome stated

  • In the reviewer’s example, Framework can become similar to or slightly higher than the MacBook.
  • The reviewer still emphasizes longer-term value from upgrade flexibility (ports, SSD, memory).

Memory upgrade value claim

  • MacBook M5 reportedly limited to up to 32GB; 64GB requires M5 Pro.
  • Framework can scale higher:
    • Stated up to 64GB in configuration
    • Up to 96GB possible
  • This is positioned as potentially avoiding expensive platform upgrades.

Pros (unique positives mentioned)

  • Modularity / future-proofing
    • Expansion-card port flexibility tailored to workflows.
  • Premium build feel
    • Confidence from the metal lid.
  • Linux developer readiness
    • Fedora works after updates; explicitly aimed at Linux dev.
  • Strong multi-core performance
    • Good results for real compilation workloads, especially larger projects.
  • Upgradable/swappable memory
    • Enables running larger local LLMs than a 16GB MacBook (when supported by the software backend).
  • SSD choice flexibility
    • Useful for customizing development storage configurations.

Cons (unique negatives mentioned)

  • Single-core performance / JS benchmarks favor MacBook
  • AI tooling compatibility on Intel is initially limited
    • LM Studio’s Intel behavior can be slower due to support/tooling limitations.
    • Requires alternative llama.cpp backend usage (e.g., “Sickle”).
  • Lower measured memory bandwidth vs Apple
    • Stream benchmark: 97k vs 136k MB/s, contributing to slower baseline token generation.
  • Added customization costs
    • Power adapter may be extra; expansion modules increase total cost.
  • Fan noise under sustained heavy load
    • Not quiet during peak multi-core workloads.

Comparisons made in the video

  • Primary comparison: Framework Laptop 13 Pro (Intel + Linux) vs MacBook Pro M5

    • MacBook leads in single-thread / JS responsiveness and some small cold-build cases.
    • Framework leads in multi-core compilation and larger project builds.
    • Framework also offers memory upgrade flexibility.

  • Additional mentioned context

    • Discussion around Apple “Pro” branding tiers and memory scaling limits.
    • Intel support state vs newer Intel variants (Ultra series / Panther Lake noted as support “probably coming soon”).
    • Suggestions to consider alternatives with better software support (including Ryzen AI 300 as more established; and Vulcan compatibility considerations).

Overall verdict / recommendation (based on the video)

  • Framework Laptop 13 Pro is presented as a strong Linux developer machine, especially for:

    • Multi-core compilation
    • Larger codebases
    • People who want control over hardware upgrades (ports, SSD, memory)

  • If the workload is mainly single-threaded or dominated by JS/frontend benchmarks, the MacBook Pro M5 remains faster.

  • For local AI inference, Framework’s more RAM is a major advantage, but real performance depends on Intel software backend support. LM Studio alone may underperform until configured correctly.

Unique points mentioned about the product (consolidated list)

  • Modular port system with swappable modules (USB-A, DP, HDMI, Ethernet, USB-C, microSD)
  • Screwdriver/module swapping approach
  • Premium metal lid; “thin” look with bezel separate
  • Weight near MacBook Air range
  • Linux dev workflow validation: Fedora install + recommendation (Fedora 44)
  • Intel chip support required Fedora update
  • Keyboard: longer travel and MacBook-like sound; tappad is haptic and responsive
  • 10Gb Ethernet module mentioned
  • HDMI supports second display; dragging windows works
  • Speedometer JS benchmark: Framework lower than MacBook
  • Multi-core build performance: Framework faster for larger builds
  • Thermals: slightly cooler during .NET builds; fans audible under sustained load
  • Memory architecture: LP CAM DDR5X swap-able; contrasted with Apple soldered limitation
  • Stream benchmark: Framework lower memory bandwidth
  • AI: LM Studio Intel performance slower without proper backend
  • Workaround/fix: use llama.cpp “Sickle” backend for improved Intel performance; differences between Vulcan vs Sickle
  • Larger quantized LLM feasibility with 64GB memory
  • Pricing/config comparisons include expansion module and power adapter costs
  • Framework memory upgrade ceiling: 64GB shown; up to 96GB possible
  • SSD choice flexibility highlighted as key for development workloads

Speakers / roles

  • Only one primary speaker appears in the subtitles, handling both the review and benchmark comparisons.

Rate this summary

Your feedback will help improve summaries.

Improve this summary

Reprocess with a stronger model when the summary feels incomplete or inaccurate.

Pro

Translate summary in another language

Pro

Ask questions to this video

Chat for follow-up questions, clarifications, and source-backed answers.

Coming soon

Share this summary

Share on X/Twitter Share on LinkedIn Share on Reddit

Original video