nEVEn: Checkpoint

1. The Core Problem: The Nightmare of SketchUp Crashes & Version Chaos

In professional 3D architectural modeling, design progress is constantly threatened by software crashes, disruptive auto-saves, and chaotic file management.

Traditional SketchUp File Disaster:
📁 Project_Folder/
   ├── 📄 Project_Initial.skp                  (Heavy file)
   ├── 📄 Project_Final.skp                    (Heavy file)
   ├── 📄 Project_Final_v2.skp                 (Heavy file)
   ├── 📄 Project_Final_v2_client.skp          (Heavy file)
   ├── 📄 Project_FINAL_APPROVED.skp           (Heavy file)
   └── 📄 Project_FINAL_REAL_v3.skp            (Heavy file)
   Massive disk space wasted! Confusion: Which file is truly current?

A. The "Auto-Save Ambush" & The "Not Responding" White Screen

Almost every SketchUp user has suffered from the classic Auto-Save ambush:

• The Blind Mid-Command Freeze: You are in the middle of a critical modeling stroke - drawing a precision line, moving a heavy group, or orbiting around a complex facade. Suddenly, SketchUp’s native Auto-Save silently kicks in without warning.
• The Accidental Click Panic: Because there was no prompt, you think your mouse or keyboard lagged. You click or drag again. Windows immediately flags SketchUp as unresponsive: the viewport fades white with a spinning blue cursor and the dreaded SketchUp (Not Responding) banner.
• The Inevitable BugSplat: One click too many while frozen, and SketchUp crashes instantly with a BugSplat. The very feature meant to save your progress actually caused the crash, corrupting both the live file and the recovery file (AutoSave_*.skp).

B. "Save-As Hell" & Hard Drive Exhaustion

To protect themselves against crashes, architects manually duplicate files before every major change. Within weeks, the project folder becomes a disaster zone:

• Gigabytes of Redundant Data: Heavy models copied multiple times rapidly exhaust workstation and studio server storage.
• Broken Paths & Lost Textures: Renaming files frequently severs links to external render assets, 3D proxy paths, and linked material maps.
• Version Confusion: In team environments, nobody knows whether Final_v2.skp or Final_APPROVED.skp contains the structural grid adjustments or client facade revisions.

C. The Paralysis of Creative Experimentation

When trying out alternate design ideas (such as testing an alternate roof geometry, a cantilevered balcony, or a parametric louvre facade), architects are paralyzed by fear:

• SketchUp’s Undo stack is fragile and easily cleared.
• Closing a file or switching scenes permanently purges the Undo history.
• Designers hesitate to explore bold creative concepts because undoing a complex change manually is tedious and prone to error.

nEVEn Checkpoint Vault is built specifically to kill these problems forever. It is not just an incremental feature; it is nEVEn’s primary, true innovation - a high-speed, crash-proof time machine designed to give architects complete creative freedom and peace of mind.

2. What Makes Checkpoint a True Painkiller Innovation?

Unlike conventional backup tools that simply copy-paste massive files or freeze your screen without warning, nEVEn replaces outdated workflows with an intelligent, architect-first version control system:

nEVEn Clean Architecture:
📁 Project_Folder/
   ├── 📄 Project_Model.skp                    (Single active modeling file)
   └── 📁 nEVEn_checkpoints/                   (Dedicated Project Vault)
         ├── 📄 _DO_NOT_DELETE_nEVEn_CHECKPOINTS.txt  
         └── 📁 Project_Model/                 (Protected Model History)
               ├── 🏷️ MASTER Checkpoint [M]    (Anchor baseline)
               ├── 🏷️ R01: Concept Layout      (Incremental revision checkpoint)
               ├── 🏷️ R02: Design Option B     (Incremental revision checkpoint)
               └── 🏷️ R03: Client Revisions    (Incremental revision checkpoint)

3. High-Speed Architecture: Protection Built for Architects

nEVEn’s Checkpoint Vault is engineered for maximum speed and rock-solid reliability:

A. Smart Non-Duplicating Storage

When you save a checkpoint, nEVEn does not duplicate your entire 3D model, high-res textures, and component libraries over and over again. Instead, it intelligently logs model milestones in an ultra-compact format. This allows you to maintain dozens of revision checkpoints while consuming only a small fraction of the disk space required by traditional duplicated .skp files.

B. High-Speed In-Memory Native Core

Previous generation tools relied on external background utilities that caused SketchUp’s viewport to hitch, stutter, or enter "Not Responding" states. nEVEn processes checkpoints directly in high-speed system memory, completing in sub-seconds with zero modeling interruption.

C. Clean Tab & Workspace Cleanliness

In SketchUp 2027 and modern versions, saving or inspecting checkpoints respects your active workspace:

• **No False Modified Asterisks (*):** Many extensions modify internal model dictionaries during inspection, tricking SketchUp into thinking you have unsaved changes. nEVEn keeps your active model completely untouched.
• Document Tab Synchronization: Taking a checkpoint synchronizes cleanly with SketchUp’s document tab engine, clearing modified indicators across all open document tabs.

D. Crash-Proof Integrity

To guarantee your active project is never corrupted:

• Checkpoints are safely verified before committing to the vault.
• Even if your workstation loses power or SketchUp is forcefully terminated mid-session, your active .skp model and historical checkpoints remain 100% intact.
• Full support for deep folder paths, office network shares, and international project directory names.

4. The Version Hierarchy: Master Baseline vs. Revisions

nEVEn organizes your design timeline into a clean, intuitive architectural hierarchy:

Checkpoint Version Hierarchy:
[ MASTER BASELINE ] ➔ The solid, verified foundation (e.g., Municipal Submission / Concept Sign-off)
       │
       ├── [ R01 ] ➔ Revision 1 (e.g., "North Elevation Window Modifications")
       ├── [ R02 ] ➔ Revision 2 (e.g., "Parametric Screen Wall Added")
       ├── [ R03 ] ➔ Revision 3 (e.g., "Terrace Pergola & Landscape Adjustments")
       └── [ R04 ] ➔ Revision 4 (e.g., "Client Meeting: Reduced Kitchen Island")

A. The Master Checkpoint & The [ M ] Badge

• The Master Checkpoint represents your foundational baseline, marked by a distinct blue [ M ] badge on its card.
• Update & Dependency Protection: A Master checkpoint can be updated with the current model state, unless newer checkpoints depend on it. If newer revisions rely on it, nEVEn automatically locks it against accidental deletion or overwriting (Cannot delete / update: newer checkpoints depend on this checkpoint. Save as a new revision instead).
• Automated New Master (10-Revision Cycle): After every 10 sequential revisions, nEVEn automatically establishes a fresh Master checkpoint, keeping your project's version chains rock-solid, resilient, and lightweight.

B. The Checkpoint Window: Complete Interface Anatomy

When you open Checkpoint (click c on the toolbar or select Extensions > nEVEn > Checkpoint), the visual window is organized into three clean zones:

1. Top Header & Action Bar:

• CHECKPOINT NAME Input Box: The only place where you can type a custom note or title. It automatically pre-fills with the next sequential revision tag, but you can overwrite it with your own description.
• [ SAVE CHECKPOINT ] Action Button: Clicking this button saves your current model state immediately and cleanly without any confirmation popup.
• Dynamic [ UPDATE CHECKPOINT ] Transformation: If you select (click) any existing card in the feed, this top-right button dynamically transforms into [ UPDATE CHECKPOINT ]. Clicking it displays a confirmation prompt to overwrite that specific checkpoint with your active model state (unless newer checkpoints depend on it). Click outside to deselect and return to SAVE CHECKPOINT.

1. Central Card Feed:

• 3D Perspective Thumbnail: Visual camera preview captured at the moment of saving.
• Title & Delete Icon (🗑️): Name of the revision alongside a quick deletion control (automatically locked if newer checkpoints depend on it).
• Elapsed Relative Time & Storage: Displays relative time elapsed (Just now, 30m ago, 2h ago) and disk storage.
• Master Badge ([ M ]): Distinguishes base Master checkpoints from incremental revisions.
• Action Buttons:
• [ SAVE AS ]: Exports that revision as an independent, standalone .skp design option file without modifying your active workspace.
• [ LOAD ]: Restores that checkpoint directly into your current SketchUp session.

1. Bottom Status Footer:

• Bottom-Left Telemetry: Live disk footprint and efficiency ratio (e.g., storage on disk and percentage saved).
• Center Identity: © N1LESH Tools (direct link to the official site).
• Bottom-Right Counter: Live count and tier limit (e.g., 2 / 2 Checkpoints in Free Edition, or total revisions in Pro).

5. Capturing Checkpoints: Daily Workflows & Best Practices

nEVEn offers multiple intuitive ways to create checkpoints tailored to your drafting speed:

Top Menu: [Extensions] 
             └── [nEVEn 2027]
                    ├── Run Manual Scan
                    ├── Checkpoint                ➔ Opens Visual Checkpoint Window
                    ├── Save Checkpoint Prompt    ➔ Quick 1-Click Prompt
                    ├── Purge + Save
                    ├── Purge + Save + Rescan
                    └── Settings

A. Direct Quick Save (Save Checkpoint Prompt) & The Prompt Dialog

For fast saves without opening the full visual window:

1. Select Extensions > nEVEn > Save Checkpoint Prompt (or press your custom keyboard shortcut).
2. A compact modal appears showing your project name, model size, and elapsed time since your last checkpoint (e.g., "Last checkpoint: 25 min ago (R01)").
3. Automated Naming: In quick prompts and reminders, nEVEn automatically resolves the next sequential revision code (R01, R02...) and project name. You do not need to waste drafting time typing names - custom descriptions are reserved exclusively for the Main Checkpoint Window.

B. Dynamic Context-Aware Prompt Buttons

nEVEn continuously monitors which checkpoint is currently active in your session. When the prompt appears (via shortcut, top menu, or background reminder), its buttons dynamically adapt to your exact working context:

• Scenario 1: Fresh Model (No Checkpoints Yet)
• [ SAVE FIRST CHECKPOINT ]: Captures your initial baseline Master checkpoint.
• [ ASK LATER ]: Snoozes the prompt so you can continue initial layout drafting.
• [ MANUAL ONLY ]: Silences automatic reminder popups if you prefer manual saves.

• Scenario 2: Working on Latest Revision (Overridable)
• When working on your current checkpoint and no newer revisions depend on it:
• [ UPDATE CURRENT CHECKPOINT (R01) ]: Overwrites the active checkpoint with your latest modeling changes, keeping your timeline tidy without cluttering it with micro-revisions.
• [ SAVE AS NEW (R02) ]: Preserves the previous checkpoint and captures your current work as the next sequential revision.
• [ ASK LATER ]: Snoozes the reminder for your next work interval.

• Scenario 3: Working on an Earlier Milestone (Protected Foundation)
• When you have loaded an earlier checkpoint upon which newer revisions already depend, nEVEn automatically protects historical integrity by locking overwrite actions:
• [ SAVE AS NEW (R03) ]: Leaves the foundational checkpoint safely intact and branches your new changes into the next revision code.
• [ ASK LATER ] | [ MANUAL ONLY ]

C. Pro-Tip: Assign a Keyboard Shortcut (Ctrl+Shift+S)

To draft with ultimate speed, assign a native SketchUp shortcut to nEVEn:

• Open SketchUp top menu: Window > Preferences > Shortcuts.
• Search for Save Checkpoint Prompt and assign a fast shortcut such as Ctrl + Shift + S (or your preferred key).
• Whenever you finish a complex drawing sequence, press your shortcut for an instant popup, choose whether to update current or save as new with dynamic buttons, and keep modeling without touching the mouse menu.

D. Proactive Checkpoint Reminders: Building Drafting Muscle Memory

Unlike SketchUp's native Auto-Save which freezes your screen mid-stroke without warning:

• nEVEn features gentle, scheduled reminder popups (configured in Pro for 15, 30, 45, or 60 minutes).
• Controlled Automation: When the reminder appears, you have full manual control: finish your active line or drag, take your time, and save safely on your terms.
• The Muscle Memory Advantage: Within a few days of modeling, these gentle prompts build subconscious design muscle memory. You naturally develop the habit of pausing, breathing, and locking in your design stages, eliminating BugSplat panic forever.

6. Integrated Model Sanitization: Purge Before Checkpoint Save

A true design safety net must not immortalize model junk. Saving a checkpoint of a bloated, corrupted model defeats the purpose of version control.

nEVEn integrates deep model sanitization directly into every checkpoint save:

The Checkpoint Pipeline:
[ Initiate Checkpoint ]
        ↓
[ 1. Execute Configured Purge ] ➔ Eliminates unused components, dead materials, and orphaned tags
        ↓
[ 2. Capture Design State ]     ➔ Preserves active 3D model geometry and materials in high-speed memory
        ↓
[ 3. Native Model Save ]       ➔ Synchronizes live document tab cleanly
        ↓
[ 4. Finalize to Vault ]       ➔ Commits verified checkpoint to nEVEn_checkpoints/

Purge Preferences & Default Settings:

• Free Edition Defaults: Auto-Save Model is ON by default, ensuring your live .skp file and checkpoint vault stay in sync. Purges are OFF by default to keep initial saves ultra-fast.
• Pro Edition Customization: In Pro, you can configure your exact purge depth in Settings:
• Native Purge: Fast, standard cleanup of unplaced component definitions, unused materials, and empty layers.
• Absolute Purge: nEVEn’s deep algorithmic purge - recursively hunting nested unplaced definitions, orphaned layer hierarchies, dead styles, and lingering third-party plugin data dictionaries.
• Auto-Save Synchronization: When enabled, taking a checkpoint automatically saves your active .skp file in lockstep, guaranteeing that your disk file and checkpoint vault are 100% synchronized.

7. Instant Time Travel: Loading & Restoring Checkpoints in 1 Click

The true power of nEVEn Checkpoint Vault is the ability to travel backward and forward in time without fear. Unlike naive file-opening scripts that risk crashing SketchUp or cluttering your screen, nEVEn features an intelligent, multi-layered loading engine that protects your work across every modeling scenario.

The 1-Click Loading Workflow:

1. Open the Checkpoint window (click c on the toolbar or press Ctrl+Shift+S).
2. Browse through your checkpoint cards in the visual timeline.
3. Select the target checkpoint and click LOAD.
4. nEVEn instantly evaluates your active session and displays a context-aware confirmation modal (Load Checkpoint?).

Intelligent Session Awareness: How nEVEn Handles Every Load Scenario

Restoring an earlier design state in 3D modeling can be hazardous if unsaved work is in progress. nEVEn eliminates this danger through live session awareness:

Scenario 1: Clean Model Switch (Zero Unsaved Changes)

When your active model has no unsaved strokes, clicking LOAD presents a clean two-button confirmation:

• [ LOAD NOW ]: Replaces the active session with the selected checkpoint in a single smooth transition.
• [ CANCEL ]: Closes the dialog, leaving your workspace untouched.

Scenario 2: Unsaved Changes Detected (Save & Load vs. Discard)

If you have modified the viewport or saved changes to disk since your last checkpoint, nEVEn proactively intercepts the load command with an Unsaved Changes Detected alert so work is never lost:

• When Working on an Overridable Revision:
• [ UPDATE CURRENT (R01) & LOAD ]: Updates your active revision in the vault first to secure your latest edits, then immediately loads the target checkpoint. Zero work lost, clean timeline!
• [ LOAD NOW ]: Discards unsaved viewport experiments and loads the target checkpoint directly.
• [ CANCEL ]: Returns you to your viewport with unsaved work intact.
• When Working on a Protected Foundation:
• If newer checkpoints depend on your current state, nEVEn automatically protects historical integrity by locking overwrite actions and dynamically offering [ SAVE AS NEW (R03) & LOAD ], safeguarding foundational revisions before loading the target.

Scenario 3: Reverting Unwanted Modeling Strokes (The Instant Reset)

When an experiment goes wrong - such as an unwanted intersect operation, messy geometry boolean, or accidental scale shift:

• You do not need to spam Ctrl+Z (Undo) 50 times hoping SketchUp does not freeze or crash.
• Simply click LOAD on your currently active checkpoint card.
• nEVEn displays the Discard Changes & Load? dialog.
• Click [ LOAD NOW ] to instantly reset your model back to its pristine saved state in 1 second.

Scenario 4: Emergency Recovery Vault (Browse Vault)

If your active .skp file is accidentally deleted, moved, or corrupted during a system failure:

• Open a blank SketchUp session and launch Checkpoint.
• Click Browse Vault to locate your project’s nEVEn_checkpoints directory.
• Every captured checkpoint appears in the feed. Clicking LOAD reconstitutes the model and restores it directly into SketchUp, completely bypassing file loss.

The Zero-Corruption Safety Architecture:

Whenever a checkpoint is loaded, nEVEn executes a multi-stage safety sequence to guarantee zero data loss:

1. Isolated Pre-Staging: The target checkpoint is reconstituted inside an isolated temporary staging vault. Your working file is NEVER touched or modified until the restored file is 100% prepared.
2. Digital Integrity Verification: The staged model is verified against its digital signature to guarantee zero polygon loss, perfect material consistency, and clean solid geometry.
3. Pre-Restore Safety Backup & Rollback: Before swapping files, nEVEn automatically creates a temporary safety backup of your active model. If an unexpected operating system freeze or file-lock occurs, nEVEn automatically rolls back to the backup so you are never left with an empty document.
4. Clean Same-Session Swap (Zero Tab Clutter): In SketchUp 2027+ and macOS multi-document environments, nEVEn closes the active tab cleanly and loads the restored model in the exact same window. It never spawns confusing duplicate tabs or secondary application windows.
5. Live Telemetry & Timer Reset: Upon completion, the active checkpoint badge updates automatically, and background reminder timers reset cleanly.

The Real-World Superpower: Fearless Client Presentations

During client design meetings:

• You present Option A (current state).
• The client asks: "Can we see what the living room looked like before we moved the fireplace?"
• Instead of fumbling through folders or saying "I'll have to find that old file and email it tomorrow," open Checkpoint, click LOAD on R01, and reveal Option A immediately in your active workspace.
• If the client says "Yes, let's keep that," you continue from there. If they prefer the new layout, 1-click load back to R03.

8. Vault Management, Security & Studio Practices

Where Are Checkpoints Stored?

All checkpoints are saved in a dedicated local directory named nEVEn_checkpoints created directly inside your project folder alongside your .skp file:

Your Project Directory:
📁 Project_Folder/
   ├── 📄 Project_Model.skp                    <-- Your active modeling file
   └── 📁 nEVEn_checkpoints/                   <-- Dedicated project vault folder
         ├── 📄 _DO_NOT_DELETE_nEVEn_CHECKPOINTS.txt  <-- Studio Safety Notice & Protection Guide
         └── 📁 Project_Model/                 <-- Isolated model repository (Managed by nEVEn)

The Studio Safety Notice (_DO_NOT_DELETE_nEVEn_CHECKPOINTS.txt)

To ensure safety across collaborative studio environments, nEVEn automatically places an authoritative text document (_DO_NOT_DELETE_nEVEn_CHECKPOINTS.txt) directly inside the root nEVEn_checkpoints directory:

• Office & Team Protection: Prevents team members, assistants, or IT staff from accidentally deleting or moving the folder during routine storage cleanups.
• The Project Safety Guarantee: The notice documents that as long as this folder remains safe, your project progress is completely protected - even if your active .skp model file and .skb backup are accidentally deleted, lost, or corrupted by a sudden BugSplat.
• Clean Organization: Resides at the root repository level, keeping individual model subfolders neat and organized.

Key Advantages of Local Vault Storage:

1. 100% Offline & Private: No models, geometries, or textures are ever uploaded to cloud servers. Your intellectual property remains strictly on your machine.
2. Travels with Your Project: When archiving a completed job or moving it to an external backup SSD, simply copy the entire project folder. The nEVEn_checkpoints vault travels seamlessly with the .skp file.
3. Cloud-Sync Friendly: Because checkpoints avoid saving massive redundant files, services like Dropbox, OneDrive, and Google Drive sync them smoothly in the background without saturating office bandwidth.

9. nEVEn Free vs. Pro Edition Capabilities for Checkpoint

nEVEn’s version control engine is engineered to deliver uncompromised core reliability for every user, with professional studio customization in Pro:

Uncompromised Core Engine: Free edition users never suffer from artificial engine throttling or degraded performance. The speed, sub-megabyte differential efficiency, and crash protection are 100% identical to Pro. Pro delivers definite professional value by providing unlimited checkpoint capacity, automated background timer prompts and custom purge automation.

Topic Related FAQ