# JIndex Manual

JIndex is a fast file finder for your own computers. It walks the folders you tell it about **once**, writes every file and folder path into an index, and from then on finds things instantly as you type — across local drives, the NAS, and (optionally) other PCs running JIndex.

> **The short version**
> 1. Click **Index folder…** and pick a drive, folder or network path. Wait for it to finish (it runs in the background).
> 2. Type in the search box. Several words narrow the search. Double-click a result to open it.
> 3. Click **Schedule…** so the index refreshes itself automatically.
>
> After that, just open JIndex: it comes back with your last search, filters and layout exactly as you left them, and is searchable within seconds thanks to a local copy of the index.
> Everything else in this manual is detail. If the Network panel confused you, jump to *Searching other computers (server & peers)*.

---

## 1. The big picture

### What an "index" is

An index is just a text file with one path per line — every file and folder JIndex found when it scanned. Searching means scanning that list in memory, which is why results appear while you type even with millions of entries. The trade-off: the index is a **snapshot**. Files created, renamed or deleted after the scan are not reflected until the folder is indexed again (by you, by the scheduled task, or by the service).

### Where the index lives

| Location | When it is used |
|---|---|
| `\\NAS\ALL Files\JIndexShared\index_<COMPUTERNAME>.txt` | Normally. Every machine writes its **own** file here, named after the computer. |
| `%APPDATA%\JIndex\index_<COMPUTERNAME>.txt` | Fallback while the NAS share is not reachable (e.g. right after boot). JIndex keeps retrying every 15 seconds and switches to the share as soon as it answers, copying the local file over. |
| `%LOCALAPPDATA%\JIndex\cache\merged-index.cache` | **Start-up cache**: a local copy of the merged index, written after every load from the share. At start-up JIndex loads this first (seconds instead of minutes), then checks whether the share's files changed and, only if they did, re-reads the share in the background. |

The right-hand end of the status bar tells you which one is in use: **"shared index"**, **"shared index (cached)"** or **"local index"**. Hover it to see the exact file path.

When JIndex starts it loads **every** `index_*.txt` in that folder, not just this machine's (Options → Indexing → *Merge index files from other machines*). That is how you see files that live on other computers without any network set-up at all — as long as those computers write their index to the same shared folder.

### One program, four jobs

`JIndex.exe` behaves differently depending on how it is started:

| How it runs | What it does |
|---|---|
| Double-click / Start menu | The search window (this is what you normally use). |
| `JIndex.exe /scan` | Headless re-index of the *auto-scan list*, at idle priority, then exits. This is what the **JIndex_AutoScan** scheduled task runs. |
| `JIndex.exe /service` | Runs as the **JIndexService** Windows service: re-indexes the auto-scan list every 24 hours even when nobody is logged on. |
| `JIndex.exe /install` or `/uninstall` | Registers / removes that service (asks for Administrator). |

The **search server** (Network panel) is not a separate program either — it is a feature of the search window that, when switched on, lets other JIndex machines query this computer's index live. More in section 5.

---

## 2. Quick start

### Step 1 — Index something

1. Click **📁 Index folder…** (or press Ctrl+I).
2. Pick a drive from the drop-down, **Browse…** to a folder, type a network path such as `\\NAS\ALL Files`, or press **This PC** to index every local drive.
3. Click OK. Indexing runs in the background — the progress appears in the toolbar and you can keep searching while it works. A whole drive can take several minutes; a NAS share longer.
4. When it finishes, the folder is added to your **auto-scan list** automatically, so a scheduled scan (step 3) will keep it fresh.

> **Replace or add?** By default each indexing run **replaces** this machine's index. If you index `C:\` and later index `D:\`, only `D:\` remains. To build the index up folder by folder, turn on **Options → Indexing → "Add to the existing index instead of replacing it"** first. (Indexing "This PC" or a drive root in one go avoids the problem.)

### Step 2 — Search

- Just type. Results update as you type (after a short pause you can tune in Options).
- **Several words** narrow the search: `invoice 2024 pdf` finds entries whose name *or path* contains all three. Order does not matter.
- Press **Enter** to run the search immediately and remember the query in the history (🕘 button). **Esc** clears the box.
- Double-click a result (or select it and press Enter) to open it. Right-click for more actions.

### Step 3 — Keep it fresh

Click **⏱ Schedule…**, pick *Every day at 02:00* (or whatever suits), and save. Windows Task Scheduler will then run `JIndex.exe /scan` for you. JIndex notices when the scan has rewritten the index (it checks every 5 minutes) and reloads it in the background; **🔄 Refresh** (F5) does the same immediately.

### Step 4 — There is no step 4

Everything you set is saved a second after you change it and comes back when JIndex starts: the search text (it runs again automatically as soon as the index is loaded), Regex/Wildcards/Case, Match in / Show / Extensions, the selected search paths, the column you sorted by, the window size and position, and which side-panel sections are open. Closing the window keeps JIndex in the tray; launching it again (Start menu, shortcut, double-click) just brings that window forward — it never starts a second copy.

---

## 3. The main window

### Toolbar

| Button | What it does |
|---|---|
| **Index folder…** (Ctrl+I) | Scan a folder, drive or network share into the index. |
| **Schedule…** | Create or remove the Task Scheduler task that re-scans your auto-scan list automatically. |
| **Refresh** (F5) | Re-read the index files from disk. Use after a scheduled scan, after another machine finished indexing, or if the status bar says "local index" and the NAS is back. |
| **Options…** (Ctrl+O) | Every setting, in five tabs (section 6). |
| **Help** (F1) | This manual. |

### The search box

| Control | Meaning |
|---|---|
| Search box | Words to look for. Plain text search, not case sensitive, each word must appear somewhere in the name or path (Options → Search can change AND to OR). |
| 🕘 | Recent searches (those you confirmed with Enter). |
| **Regex** | Treat the whole box as one .NET regular expression, e.g. `^report_\d{4}\.pdf$`. |
| **Wildcards** | Treat the whole box as one wildcard pattern matched against the **whole** name: `*.png`, `backup_?.zip`, `*2024*report*`. |
| **Case sensitive** | `README` and `readme` become different. |

> **Common gotcha:** with **Wildcards** ticked, typing `report` only finds an item called exactly `report` (no extension). Type `*report*` — or untick Wildcards for ordinary word search. Regex and Wildcards cannot both be on.

### Quick filters (second row)

| Filter | Meaning |
|---|---|
| **Match in** | Compare your words against the *file name* only, the *full path* only, or *either* (default). "Full path" lets you search by folder name, e.g. `invoices 2024`. |
| **Show** | All items, files only, or folders only. |
| **Extensions** | Only keep these extensions, separated by `;` — e.g. `pdf;docx;xlsx`. Blank = everything. |

More filters (size, date, "hide missing files", sorting) are in Options → Search.

### The Resources slider

At the right of the filter row sits **⚡ Resources** — one slider for "how much of this PC may JIndex use". It takes effect the moment you move it and is remembered. The index itself (several GB for millions of entries) has to be in memory to search, so the slider controls everything *around* it:

| Level | Priority | Cores used by a search | Typing delay floor | Indexing / copying | Memory when idle |
|---|---|---|---|---|---|
| **Lowest** — stay out of the way | Idle | 1 | 700 ms | gentle: lowest-priority thread, pauses every 25 folders; copies 1 file at a time | trimmed after 1 min idle; **index released after 5 min hidden in the tray** |
| **Low** | Below normal | ¼ of the cores | 450 ms | gentle; half the copy threads | trimmed after 3 min; index released after 20 min in the tray |
| **Normal** (default) | Normal | ½ of the cores | your setting | normal | trimmed after 15 min idle |
| **High** | Normal | ¾ of the cores | your setting | above-normal thread | kept |
| **Max** — everything this PC has | Above normal | all cores | your setting | above-normal thread; double copy threads | kept |

- *Trimmed* means JIndex hands its memory back to Windows; the pages stay cached and come back on demand, so only the first search afterwards is a touch slower — but other programs can take the RAM if they need it.
- *Released* means the whole index is dropped while JIndex sits unused in the tray (it then needs ~100 MB instead of several GB). The moment you open the window or type, it reloads from the local cache — a few seconds — and your search runs. The index is never released while the search server is running or a scan is in progress.
- Hover the slider for the exact numbers on this machine; the same setting is in Options → Interface.

Hint: if the PC feels sluggish while JIndex is doing something big (a first index of a whole drive, a copy of thousands of files), drag the slider left for the duration — the running job slows down immediately.

### Results

- **Columns:** Name, Folder (or Full path — Options → Interface), Type, Size, Modified. Click a header to sort; click again to reverse. Drag headers to reorder.
- **Type** shows the extension, `[Folder]`, or `[MACHINE]` for a hit that came from a peer computer.
- **Grey rows** are entries that no longer exist on disk (stale index). **Blue rows** came from a peer.
- The grid shows at most *Max results* rows (default 1000); the status bar always reports the true total ("Found 12,345 items (showing 1,000)"). Narrow the search rather than raising the limit.
- Keyboard: **Enter** open · **Del** delete · **Ctrl+C** copy full path(s) · **Ctrl+Shift+C** copy name(s) · **Esc** back to the search box · **↓** from the search box jumps into the list.

### Actions (buttons under the grid, and the right-click menu)

| Action | Effect |
|---|---|
| **Open** | Open the file with its default program, or the folder in Explorer. |
| **Open location** | Explorer window on the containing folder with the item selected. |
| **Copy path** / Copy file name | Puts the full path(s) / name(s) of all selected rows on the clipboard, one per line. |
| **Copy to…** / **Move to…** | Copy or move the selected items to a folder you pick. Several at once are processed in parallel (Options → Files). |
| **Delete** | Deletes the selection — permanently or to the Recycle Bin, see Options → Files. Asks first by default. |
| Properties | Windows' file properties dialog. |
| Exclude this folder from indexing | Adds the item's folder to the exclusion list so future scans skip it. |

Items found on another machine can only be opened if their path is reachable from here (e.g. a UNC path); they cannot be copied, moved or deleted from this computer.

### Side panel

- **File details** — name, folder, full path, type, size, modified date of the selected row. Text is selectable.
- **Active search paths** — a list of folders. Select one or more and results are limited to items **under** them (nothing selected = search everything). Options → Search → *Path list acts as* flips it to **Exclude** instead. ➕ adds a folder, ➖ removes the selected ones, ✖ clears.
- **Network** — the search server switch, the peer list and the Find button. Explained in section 5.
- **Statistics** — counts and total size of the current results, and the size of the index.

Each section can be collapsed with the ^ button, or hidden entirely in Options → Interface. Drag the bar between the results and the side panel to resize it.

### Status bar

Left: what JIndex is doing ("Found 12,345 items", "Indexing…", "✓ Copied 3 paths…"). Right: **how many items are in the index and whether it is the shared or the local copy** — hover for the file path.

### System tray

Closing or minimising the window hides JIndex to the tray (so it is instantly available next time). Double-click the tray icon to bring it back — or simply start JIndex again from its shortcut: only one copy ever runs, and a second launch just shows the existing window. Right-click the tray icon → **Exit** to really quit. Both tray behaviours can be changed in Options → Interface.

### What JIndex remembers

All of this is saved automatically, about a second after each change (not only when you exit), so a crash, a kill or a Windows shutdown loses nothing:

- the search text (re-run at the next start — Options → Search → *Remember the last search*), the recent-search history
- Regex / Wildcards / Case sensitive, Match in, Show, Extensions, and every setting in Options
- the *Active search paths* list **and** which of them are selected
- the column the results were sorted by, and the direction
- window size, position and maximised state, the side-panel width, and which side-panel sections are collapsed
- the peer list and whether the server was running

---

## 4. Indexing in depth

### What gets indexed

Options → Indexing controls the scan:

| Setting | Meaning |
|---|---|
| Include subfolders / Max folder depth | Walk the whole tree, optionally stopping after N levels. |
| Index folders as well as files | Off = files only. |
| Skip hidden / system items | Ignore anything with those attributes. |
| Only index extensions | `pdf;docx` = only those file types (folders are still indexed). |
| Exclude paths containing | One pattern per line; any path containing that text is skipped. **Add common exclusions** adds `$Recycle.Bin`, `System Volume Information`, `node_modules`, `.git`, `Windows\WinSxS` — recommended when indexing a whole drive. |

### Replace vs. add

*Add to the existing index instead of replacing it* (off by default) decides whether a new scan starts from an empty index or builds on what is there. Off is the original behaviour and guarantees nothing stale survives; on is what you want when you index several separate folders one after another.

### The index folder

*Index folder* is blank by default, meaning the NAS share with the AppData fallback described in section 1. You can point it somewhere else (any folder every machine can reach); it takes effect the next time JIndex starts. **Open index folder** shows the files; **Reload index** re-reads them; **Clear this machine's index** deletes this computer's `index_<NAME>.txt` (your files are not touched).

### Keeping the index up to date — three ways

1. **By hand** — Index folder… again. Fine for a folder that rarely changes.
2. **Scheduled task (recommended)** — **Schedule…** creates the Task Scheduler task `JIndex_AutoScan`, which runs `JIndex.exe /scan` daily, hourly, at logon or when idle. It runs as *you*, so it can see everything you can, including the NAS. Needs Administrator approval once to create.
3. **Windows service** — Options → Indexing → **Install service**. `JIndexService` starts with Windows and re-indexes every 24 hours even when nobody is logged on. It runs as *LocalSystem*, which normally **cannot** open network shares such as `\\NAS\…` — so it is only useful for local drives. For NAS paths use the scheduled task.

All three re-index the **auto-scan list** (Options → Indexing → *Paths to auto-scan*). Folders you index from the main window are added to the list automatically; you can also add folders or *Add all local drives* there. The list is written to `settings.txt` in the index folder, which is what `/scan` and the service read.

> If the auto-scan list is empty, the task and the service have nothing to do and silently exit. The Schedule dialog warns you when that is the case.

**Scan now** (Options → Indexing) starts `JIndex.exe /scan` immediately in the background at idle priority — the same thing the task does — and is a good way to test the set-up.

### Picking up changes

A running JIndex checks the index folder every 5 minutes (Options → Indexing → *Reload automatically when the shared index changes*). When a scan — on this machine or any other — has rewritten an index file, it reloads in the background; the old index stays searchable meanwhile and the status bar says so. **Refresh** (F5) forces the same check-and-reload immediately. After you index a folder from the main window, the other machines' files are merged back in automatically, so nothing disappears from your results.

### The start-up cache

Reading a multi-million-entry index over the network takes minutes, so after every load from the share JIndex writes the merged index to a local file (`%LOCALAPPDATA%\JIndex\cache\merged-index.cache`, about half the size of the share's files). The next start loads that in seconds, runs your last search, and only then compares the share's index files (names, sizes, dates) with what the cache was built from — re-reading the share in the background only if something changed. If the NAS is not reachable at start-up you still get the full cached index instead of just this machine's file. Turn it off in Options → Indexing → *Keep a local copy of the index for fast start-up* (the cache file is then deleted).

---

## 5. Searching other computers (server & peers)

There are **two completely separate** ways to see another computer's files in JIndex. Most people only need the first.

### Way 1 — Share the index folder (no server needed)

If computer **B** also runs JIndex and its index folder is the same NAS share, **B**'s index file `index_B.txt` sits next to yours, and JIndex on your machine loads it automatically at start-up (and on Refresh). You will see **B**'s files in every search, no network settings required. The only requirement is that each machine indexes its own drives now and then — ideally with a scheduled task.

You can tell it is working because the Statistics panel / status bar count includes the other machine's entries and their paths appear in results.

### Way 2 — Live peer search (the Network panel)

This is for machines that **cannot** use the shared folder (a laptop away from the NAS, a machine whose index you want to query live without waiting for a scan), or simply for an up-to-the-second answer from a machine that indexes often. It has two halves:

**The server** — *"let other machines search me"*

When the server is running, this computer listens on a TCP port (default **9999**) and answers search requests from other JIndex machines using **its own index**. Nothing is shared except search results (paths). Turn it on with **▶ Start server** in the Network panel, or permanently with Options → Network → *Answer search requests from other machines* so it starts with JIndex. The green dot and the text next to it show the state.

**Peers** — *"the machines I search"*

A peer is another computer whose server you want to query, entered as `address:port` (e.g. `192.168.1.50:9999`). Add one with **➕ Peer** (type the address), or let **🔎 Find** discover them: it broadcasts on the LAN (UDP port **9998**) and every machine running the JIndex server answers with its name and item count; you are then offered to add the new ones. Each peer shows ● when it answers, ✕ when it does not.

Peers are only **queried** when **Options → Network → *Include peer results in searches*** is ticked. Then every search also goes out to all peers in parallel; their hits are appended to your results, shown in blue with `[MACHINENAME]` in the Type column, and the status bar adds "+ 120 from 2 peer(s)".

### Step by step: make "OFFICE-PC" searchable from "LAPTOP"

1. On **OFFICE-PC**: open JIndex, make sure it has indexed something, click **▶ Start server** (or tick the auto-start option in Options → Network). Allow JIndex through Windows Firewall if asked; otherwise allow inbound **TCP 9999** and **UDP 9998** (see below).
2. On **LAPTOP**: Network panel → **🔎 Find**. OFFICE-PC should appear — accept to add it. (If it does not, click **➕ Peer** and type its IP address, e.g. `192.168.1.20:9999`.)
3. On **LAPTOP**: Options → Network → tick **Include peer results in searches** → OK.
4. Search as usual. OFFICE-PC's hits appear tagged `[OFFICE-PC]`.

Firewall rules, if Windows did not prompt (run in an elevated Command Prompt on the **server** machine):

```
netsh advfirewall firewall add rule name="JIndex search server" dir=in action=allow protocol=TCP localport=9999
netsh advfirewall firewall add rule name="JIndex discovery" dir=in action=allow protocol=UDP localport=9998
```

### Things to know about peer results

- They are capped per peer (*Max results per peer*, default 500) and wait at most *Timeout* seconds (default 10).
- Peers match against the **file name** or the **full path** (*Peers match against*), not both; Regex/Wildcard/case options apply to the local search only.
- A peer result is a path **on that machine**. Open/Open location only work if the same path is reachable from here (a UNC path, or the other machine's drive shared and mapped). Copy/Move/Delete are disabled for them.
- Discovery only works on the same LAN segment (broadcast); across VLANs or VPNs add the peer by IP instead.

### Which way should I use?

| Situation | Use |
|---|---|
| All PCs can reach the NAS share | Way 1 — just schedule scans on each PC. Leave the server off. |
| A PC cannot reach the share, or you want live answers from it | Way 2 — server on that PC, add it as a peer here. |
| Both | Fine — results are merged; duplicates can appear if a file is both in the shared index and on the peer. |

---

## 6. Options reference

Options edit a copy of the settings and apply only when you press **OK**. **Restore defaults** resets everything except your path filters, history and auto-scan list. Settings are stored in `%APPDATA%\JIndex\options.ini`.

### Search tab

| Setting | Meaning | Default |
|---|---|---|
| Match against | File name / full path / either. | Either |
| Multiple terms | All words must match (AND) or any (OR). | AND |
| Case sensitive, Regex, Wildcards | Same as the toolbar check boxes. | off |
| Search as you type | Off = search only on Enter. | on |
| Remember the last search and run it again when JIndex starts | Restores the search box at start-up and searches as soon as the index is loaded. | on |
| Typing delay (ms) | Pause after the last keystroke before searching. Raise for huge indexes. | 250 |
| Min. query length | Don't search until this many characters are typed. | 1 |
| Max results shown | Rows added to the grid; the status bar still shows the true total. | 1000 |
| Search history size | Entries kept in the 🕘 menu. | 20 |
| Show / Only extensions | Same as the toolbar filters. | All / blank |
| Min / Max size (MB) | Hide files outside the range. 0 = no limit. | 0 |
| Modified within (days) | Only items changed in the last N days. 0 = any. | 0 |
| Path list acts as | Whether selected *Active search paths* include or exclude. | Include |
| Hide entries that no longer exist | Drops stale entries — costs one disk check per result. | off |
| Sort results by / descending | Pre-sort by name, path, type, size or date. Anything but *index order* must read each file's details first, so it is slower on big result sets; clicking a column header in the grid is usually enough. | Index order |

### Indexing tab

See section 4. Defaults: subfolders on, depth unlimited, folders indexed, hidden/system not skipped, no exclusions, replace (not add), merge other machines' index files, index folder = NAS share, local start-up cache on, auto-reload when the shared index changes on (checked every 5 minutes).

### Files tab

| Setting | Meaning | Default |
|---|---|---|
| Worker threads | Files copied/moved in parallel. Lower for slow shares. | 6 |
| If the name exists | Rename the new copy (`name (1).ext`), skip, or overwrite. | Rename |
| Confirm before copying or moving | Summary prompt first. | off |
| Delete to | Permanently, or Recycle Bin (undoable from Explorer). | Permanently |
| Confirm before deleting | Ask first. | on |

### Network tab

| Setting | Meaning | Default |
|---|---|---|
| Answer search requests from other machines | Start the search server with JIndex. | off |
| Server port (TCP) | Port the server listens on; peers must use the same. | 9999 |
| Discovery port (UDP) | Port used by Find. | 9998 |
| Known servers (peers) | `address:port` list — Add, Remove, Find on LAN. | empty |
| Include peer results in searches | Query peers on every search. | off |
| Peers match against | File name or full path on the peer side. | File name |
| Timeout (seconds) | How long to wait for peers. | 10 |
| Max results per peer | Cap on hits per peer (and sent by this server). | 500 |

### Interface tab

Tray behaviour (hide on minimise / on close, start hidden, notifications), which side-panel sections are shown, whether the Path column shows the folder or the full path, alternating row shading, the date format (`yyyy-MM-dd HH:mm` style), **resource usage** (same as the ⚡ Resources slider — see section 3), always-on-top, remember window size, and the base font size (7–20 pt).

---

## 7. Keyboard shortcuts

| Keys | Where | Action |
|---|---|---|
| Ctrl+F | anywhere | Jump to the search box |
| Enter | search box | Search now and remember the query |
| Esc | search box | Clear the search |
| ↓ | search box | Move into the results |
| Enter | results | Open |
| Del | results | Delete |
| Ctrl+C / Ctrl+Shift+C | results | Copy full path(s) / name(s) |
| Esc | results | Back to the search box |
| F5 | anywhere | Refresh (reload index) |
| Ctrl+I | anywhere | Index folder… |
| Ctrl+O | anywhere | Options |
| F1 | anywhere | Help |

---

## 8. Command line and files

| Command | Purpose |
|---|---|
| `JIndex.exe` | Search window |
| `JIndex.exe /scan` | Re-index the auto-scan list at idle priority and exit (used by the scheduled task; returns 2 if no list was found, 3 if it was empty) |
| `JIndex.exe /service` | Run as the Windows service (used by the service manager, not by hand) |
| `JIndex.exe /install` · `/uninstall` | Register / remove **JIndexService** (elevation required) |

| File | What it is |
|---|---|
| `<index folder>\index_<COMPUTER>.txt` | This computer's index — one path per line |
| `<index folder>\settings.txt` | The auto-scan list read by `/scan` and the service (`queue.txt` is a legacy fallback) |
| `%APPDATA%\JIndex\options.ini` | All options, `Key=Value`, lists joined with `|` |
| `%APPDATA%\JIndex\index_<COMPUTER>.txt` | Local fallback index while the share is unreachable |
| `%LOCALAPPDATA%\JIndex\cache\merged-index.cache` | Start-up cache of the merged index (safe to delete; rebuilt after the next load from the share) |
| `%TEMP%\jindex_debug.log` | Start-up log, useful if the window does not appear |

The Windows build output is `Jindex\bin\Debug\JIndex.exe` (the path the scheduled task points at — keep it there, or re-create the task after moving the program).

---

## 9. Troubleshooting

**The search finds nothing.**
- Is **Wildcards** ticked? Then `report` only matches an item named exactly `report`. Untick it or type `*report*`.
- Is the index loaded? The status bar's right end shows the count; "0 indexed" means nothing has been indexed yet *or* the load is still running (see next point).
- Is a path selected in **Active search paths**? Only items under it are shown — click it again to deselect, or ✖ Clear.
- Check the **Show** and **Extensions** filters, and the size/date filters in Options → Search.

**Start-up shows "Loading index…" for a long time / JIndex uses many GB of memory.**
The whole index is held in memory for speed, and a multi-million-entry index needs several gigabytes of RAM; that is expected. Only the very first start (or a start after the share's files changed) has to read the share, which takes a minute or two; every other start loads the local cache in seconds. If every start is slow, check that *Keep a local copy of the index for fast start-up* is on (Options → Indexing) and that there is free space on `C:` for the cache. You can keep typing while it loads — your search runs by itself the moment the index is in. Exclude junk folders (Options → Indexing → *Add common exclusions*) and avoid indexing the same tree from two machines to keep the index smaller.

**JIndex makes the PC sluggish / uses a lot of memory.**
Drag the **⚡ Resources** slider (filter row, right) to *Low* or *Lowest*: JIndex drops to idle priority, searches on one core, throttles indexing and copying, and — when it sits idle in the tray — trims its memory and then releases the index entirely, reloading it from the local cache in seconds when you come back. The memory itself (roughly 500 bytes per indexed path, so ~6 GB for 12 million entries) is the price of instant search; keeping junk folders out of the index (Options → Indexing → *Add common exclusions*) is the way to shrink it.

**My settings / search were gone after a restart.**
That was a limitation of the previous versions, which only saved when you chose Exit in the tray. JIndex now saves a second after every change — if something still isn't kept, check that `%APPDATA%\JIndex\options.ini` is writable.

**I started JIndex and got a second, empty window.**
Not any more: a second launch just brings the running copy forward. If you do see two windows, one of them is an old build — check the shortcut's target.

**The status bar says "local index".**
The NAS share was not reachable when JIndex started. It retries every 15 seconds and switches over by itself (press Refresh to hurry it). While local, you only see what this machine indexed, and what you index now is copied to the share when it comes back.

**Results include files that no longer exist (grey rows).**
The index is a snapshot — re-index the folder, or tick Options → Search → *Hide entries that no longer exist on disk*.

**I indexed a second folder and the first one disappeared.**
Scans replace this machine's index unless *Add to the existing index* is on (Options → Indexing). Turn it on, or index the drive root / "This PC" in one go.

**The scheduled task runs but nothing changes.**
Its path list (`settings.txt` in the index folder) is probably empty. Open Options → Indexing and check *Paths to auto-scan*; add the folders or drives and press OK — that rewrites the file. Use **Scan now** to test, then **Refresh**.

**"Find" does not find the other computer.**
On the *other* machine JIndex must be running with the server started (green dot). Its firewall must allow UDP 9998 and TCP 9999 inbound. Both machines must be on the same local network segment. If all else fails, add it by IP with ➕ Peer — that only needs TCP 9999.

**Peer results appear but I cannot open them.**
They are paths on the other computer. Open them through a share (`\\OFFICE-PC\c$\…` if you have rights) or on that machine.

**The service never indexes the NAS.**
It runs as LocalSystem, which has no network credentials. Use the scheduled task for network paths; keep the service for local drives only (or don't install it at all).

**The window never appears.**
JIndex may be hiding in the tray (double-click the icon) or was started with *Start hidden in the tray*. If the icon is missing too, look at `%TEMP%\jindex_debug.log`.

---

## 10. Glossary

| Term | Meaning |
|---|---|
| **Index** | The list of paths JIndex searches. One text file per computer in the index folder. |
| **Index folder / shared store** | The folder holding all index files — the NAS share by default, `%APPDATA%\JIndex` as fallback. |
| **Auto-scan list** | Paths re-indexed by the scheduled task and the service; lives in `settings.txt`. |
| **Scheduled task** | Windows Task Scheduler entry `JIndex_AutoScan` created by Schedule…; runs `JIndex.exe /scan`. |
| **Service** | `JIndexService`, an optional Windows service that re-indexes every 24 h as LocalSystem. |
| **Server** | This computer's JIndex answering search requests from other computers (TCP 9999). |
| **Peer** | Another computer's JIndex server that this computer queries when *Include peer results* is on. |
| **Discovery / Find** | UDP broadcast (port 9998) that lists the servers on the LAN. |
| **Active search paths** | Optional folder filter on the main window (include or exclude). |