Skip to main content

​
Common Questions

Sync Folds works with any file syncing solution that syncs your Obsidian vault, including:
  • Obsidian Sync (official)
  • iCloud
  • Dropbox
  • Git
  • Self-hosted solutions (Syncthing, CouchDB, etc.)
  • Any other cloud storage or file syncing service
The plugin stores fold states in .obsidian/plugins/sync-folds/data.json, which syncs automatically with your vault.
Just make sure the plugin is installed and enabled on all devices where you want fold states to sync.
Yes! Sync Folds is fully compatible with both iOS and Android.According to the manifest, isDesktopOnly is set to false, meaning the plugin is designed to work seamlessly across all platforms where Obsidian is available.Install the plugin on your mobile devices and your fold states will sync automatically.
Very minimal. The plugin stores fold states as JSON data in data.json.Each fold state contains:
  • File path
  • Line numbers for fold start/end positions
  • Total line count
For example, a vault with hundreds of files and dozens of folds typically uses less than a few kilobytes of storage.
The data is stored as compact JSON, making it extremely storage-efficient even for large vaults.
If you disable Sync Folds:
  1. Existing fold states remain in localStorage - Your current fold states on that device will stay intact
  2. No syncing occurs - Changes won’t be saved to data.json or synced across devices
  3. Data is preserved - The data.json file remains in your vault with all saved fold states
When you re-enable the plugin, it will resume syncing and restore fold states from data.json.
You can also disable sync programmatically by setting enableSync: false in the plugin settings while keeping the plugin active.
Yes! Sync Folds provides a manual export command:
  1. Open the command palette (Cmd/Ctrl + P)
  2. Search for “Export folds from local storage”
  3. Run the command
This manually exports all current fold states from localStorage to the data.json file.
The plugin automatically exports fold states as you work (debounced to 150ms), so manual export is typically only needed for troubleshooting.
Your fold states are automatically backed up through your vault sync solution.The fold data is stored in:
.obsidian/plugins/sync-folds/data.json
Additional backup options:
  • If using Git, the data.json file is committed with your vault
  • If using cloud storage, it’s synced with your vault backups
  • You can manually copy the data.json file for archival purposes
Since fold states are part of your vault structure, they benefit from the same backup and versioning systems you use for your notes.
The plugin stores only fold state information:
{
  "path/to/file.md": {
    "folds": [
      { "from": 10, "to": 25 },
      { "from": 50, "to": 75 }
    ],
    "lines": 100
  }
}
Data structure (from src/types.ts):
  • File path - Relative path to the note
  • Folds array - Start and end line numbers for each fold
  • Lines - Total line count in the file
No content from your notes is ever stored, only the structural fold positions.
Absolutely. Sync Folds operates 100% locally:
  • No network requests are made
  • No external services are contacted
  • No telemetry or analytics are collected
  • All data stays within your vault
The plugin simply moves fold state data from Obsidian’s localStorage (which doesn’t sync) to a file in your vault (which does sync with your chosen solution).
The plugin is open source under the MIT license. You can review the complete source code at github.com/itsonlyjames/obsidian-sync-folds.
Minimal. The plugin is designed for efficiency:On plugin load:
  • Quick localStorage import/export (one-time per session)
  • No ongoing background processes
During use:
  • Fold changes are debounced to 150ms (see src/main.ts:181)
  • Only modified folds are updated
  • Lightweight JSON operations
Storage operations:
  • Reads/writes small JSON files
  • No vault scanning or file watching
The 150ms debounce means even rapid folding/unfolding only triggers one save operation, minimizing performance impact.
Unlikely. Sync Folds uses safe interception patterns:How it works (from src/main.ts:130-159):
  • Intercepts localStorage.setItem and localStorage.removeItem
  • Only monitors keys prefixed with {appId}-note-fold-
  • Preserves original localStorage behavior
  • Restores original methods on unload
Potential edge cases:
  • Other plugins that modify fold states might not sync automatically
  • Plugins that also intercept localStorage could theoretically interfere (rare)
If you experience issues, try:
  1. Disable other plugins temporarily to isolate the conflict
  2. Use the manual import/export commands as a workaround
  3. Report the issue at github.com/itsonlyjames/obsidian-sync-folds/issues

​
Still have questions?

If your question isn’t answered here, you can:
  • Check the GitHub repository for more information
  • Open an issue for bugs or feature requests
  • Review the source code - it’s open source under the MIT license

Build docs developers (and LLMs) love

Get started for freeTalk to us