# OLAINDEX: putting a browsable index in front of OneDrive

> A Laravel application that turns a Microsoft Graph connected OneDrive account into a password protected file browser with previews, in-directory search and short sharing links. The install is five shell commands, and the version claims in the README deserve a second look.

**WangNingkai/OLAINDEX** — ✨ Another OneDrive Directory Index

- Repository: https://github.com/WangNingkai/OLAINDEX
- Website: https://OLAINDEX.JS.ORG
- Stars: 2,209 · Forks: 564
- Language: PHP
- License: MIT
- Published: 2026-10-08 · Updated: 2026-10-08 · Language: en
- Canonical page: https://hysenlabs.com/projects/wangningkai-olaindex

## A Laravel app standing in front of Microsoft Graph

OLAINDEX describes itself as a sleek OneDrive directory index application built on the Laravel framework and powered by the Microsoft Graph API. That is the whole architecture in one sentence: a self-hosted PHP application that holds the connection to OneDrive and presents the resulting file tree as a browsable site.

The repository topics confirm the shape of it: `directory-lister`, `laravel-framework`, `olaindex` and `onedrive`. The tree looks like a standard Laravel application rather than a single-file project, with the expected directories present: `app/`, `bootstrap/`, `config/`, `database/`, `public/`, `resources/`, `routes/`, `storage/` and `tests/`, plus `artisan`, `composer.json`, `server.php`, a `Procfile` and a `phpunit.xml`. There is also a `Dockerfile`, a `docs/` directory and a `CLAUDE.md`.

The README is explicit about where this project came from: it was inspired by oneindex, a separate OneDrive directory indexer. That lineage matters when you are choosing between them, because the two share a premise while differing in framework and in how much they take on themselves.

The features list is short and concrete. OneDrive directory indexing with a clean UI, rich file preview for images, videos, audio, code and documents, password-protected directories and hidden paths, in-directory search that needs no API calls, a short URL sharing mode, resource preloading for faster access, multiple themes with Bootstrap and Material Design named as the defaults, and multi-account support.

## Five commands from clone to running application

The quick start is the shortest part of the README, and it is worth reading closely because of what it does not say:

```bash
git clone https://github.com/WangNingkai/OLAINDEX.git
cd OLAINDEX

# Install dependencies
composer install

# Initialize application
composer run install-app

# Set permissions
chmod -R 755 storage
chown -R www:www *
```

The two Composer steps do different things. `composer install` pulls the PHP dependencies, and `composer run install-app` is the Laravel command that creates the application key and prepares the framework. Skipping the second one is the most common way to end up with an unconfigured application.

The permission commands at the end matter more than they look. `chmod -R 755 storage` gives the web user access to the writable directories Laravel needs, and `chown -R www:www *` assumes a Debian-style `www` user, which will not exist on Alpine, on macOS, or inside the Docker image described below. If you are not deploying behind Apache with a `www` user, translate that line rather than running it.

Notice what is absent. There is no web server configuration in the quick start, and no instruction for connecting a OneDrive account. The README's documentation links cover environment requirements, an installation guide, account setup, configuration, an API reference and an FAQ, and account setup is a separate page, which tells you the Graph connection is a manual step you do after the code runs.

## Two PHP version answers that do not match

This is the contradiction in this repository, and both facts are current, so it is worth laying them out rather than picking one.

The README requirements section says PHP >= 7.4, followed by the extension list: OpenSSL, PDO, Mbstring, Tokenizer, XML, Ctype, JSON, BCMath and Fileinfo, plus Composer. The `Dockerfile` in the repository is built on `FROM php:7-cli-alpine` and installs only the `bcmath` extension explicitly, then sets the timezone to Asia/Shanghai, creates a dedicated `olaindex` user and group, and runs the application through `php artisan serve` on port 8000. Both point to PHP 7 as the intended runtime.

Against that, `.env.example` carries a line that disables deprecation reporting with a note explaining that Laravel 8 does not fully support PHP 8.4, and that the setting should be switched to true when you want debug output. That comment only makes sense on a PHP version where those deprecations appear, and it tells you the application is expected to run on PHP 8 at least often enough for the warning to be needed.

Neither answer is decorative. `php:7-cli-alpine` gives you PHP 7, which is past end of life, while a host that only offers PHP 8.4 is what most current shared hosting provides. The practical test is cheap: run `composer run install-app` on the version you intend to deploy and see whether the application boots, rather than trusting either document.

The `.env.example` file is also the clearest statement of the defaults you inherit: `DB_CONNECTION=sqlite`, `CACHE_DRIVER=file`, `QUEUE_CONNECTION=sync`, `SESSION_DRIVER=file` with `SESSION_LIFETIME=120`, `APP_DEBUG=false`, and an `API_LIMIT` entry defaulting to `127.0.0.1,192.168.1.1`, which is an IP allowlist for API access.

## The default branch is dev, the links say master

The repository's default branch is recorded as `dev`. The README's own links do not agree with that. The license badge points at `blob/master/LICENSE`, and the README badges for stars and license both reference the `master` path.

In practice the clone command in the quick start hides the problem, because `git clone` without a branch argument takes the default branch, which is `dev`. What breaks is any link or instruction built from a hard-coded `master` path. If you follow the README's license link from a checkout of `dev`, you are asking GitHub for a branch that is not the default, and you may land on a different or older state of the file.

The honest way to handle this is to treat `dev` as the branch you get and verify what you need from it rather than assuming the badge path reflects the default. The topics and description suggest this is the active line of development, since the repository is not archived and the last push was on 2026-04-23.

The release history adds a third layer. The most recent GitHub release is v6.0, published on 2020-12-31, and the two before it, v5.0 and v4.0, carry the word for archived in their release names. Meanwhile the repository itself is not archived. Those are different things: a maintainer can archive individual old major versions while continuing to push commits to the default branch, and that appears to be the situation here. The practical consequence is that a release tag tells you almost nothing about how current your checkout is.

## Passwords, hidden paths and search without the API

The feature that distinguishes OLAINDEX from a plain directory listing is access control. The README lists password-protected directories and hidden paths as separate capabilities, which means you can expose a tree publicly while keeping some parts of it closed.

That is a meaningful design choice for a OneDrive indexer, because the underlying account usually contains more than you intend to publish. OneDrive sharing links have their own semantics and their own expiry rules; a self-hosted index lets you decide what a visitor sees. It also means you are responsible for the access control, since there is no third party between your application and the files.

The in-directory search feature is documented as needing no API calls. That is worth understanding rather than taking on faith: search runs against the directory listing the application already has, not against Microsoft Graph. The v6.0 release notes list this under simplifying the feature set, alongside optimizing the encryption and hiding behaviour and improving the path mode, and the README presents the same item as search that avoids API calls.

Short URL sharing mode and resource preloading come from the same release notes, as does a new backend management interface. Short URL mode is the one to be careful about describing: it makes a OneDrive-backed short link for sharing, which is not the same thing as a general purpose URL shortener, and the release notes describe it as convenient for sharing.

File preview is the other substantial feature, covering images, video, audio, code and documents. For a directory indexer this is the difference between a file list and something people will actually browse, and it is also the part most dependent on what OneDrive returns for a given file type.

## Running it in Docker instead

The `Dockerfile` in the repository is short enough to read as a deployment guide in its own right, and it makes decisions that the quick start leaves open.

The base image is `php:7-cli-alpine`, so this is an Alpine build with PHP 7 and no web server. The build installs `tzdata`, `git` and `composer`, hardcodes the timezone to Asia/Shanghai, clones the repository at depth 1, runs `composer install -vvv` and then `composer run install-app`. It creates a group and a user both named `olaindex` with uid 900, chowns the application directory to them and sets the storage directory to 755.

The entrypoint is the part that changes how you deploy. Rather than Apache or nginx, the container runs the Laravel development server:

```bash
CMD ["su", "olaindex", "-c", "php artisan serve --host=0.0.0.0 --port=8000 --tries=0 --no-interaction"]
```

`--tries=0` and `--no-interaction` mean it will keep restarting the server rather than exiting, which is what you want in a container. Binding to `0.0.0.0` on port 8000 is what makes it reachable outside the container. What you do not get is a production web server, TLS termination or process supervision, so this is a reasonable way to try the application and a weaker way to run it under real traffic.

There is a `Procfile` in the tree as well, which suggests a PaaS deployment path such as Heroku-style process management. The README does not document it, so if that is your target you would be reading the tree rather than the docs to work it out.

## Where OLAINDEX sits against oneindex

The README credits oneindex as the project that inspired this one, and that is the comparison to start from, because the premise is identical: expose a OneDrive account as a browsable directory instead of a pile of share links.

The difference in approach is the framework and the consequence that follows from it. oneindex is a standalone PHP project with its own conventions, while OLAINDEX is a Laravel application, which brings routing, a migration system, a service layer and a test suite with it, along with the need to keep a full framework and its dependencies current. What you get in return is the standard Laravel tooling, the `artisan` command line, `phpunit.xml`, and a `.env` driven configuration rather than hardcoded values.

For a file indexer the framework is arguably more than the job needs, and the `.env.example` is a fair measure of how much surface there is to keep patched: cache drivers, queue connections, session lifetimes, Redis settings and a database choice between SQLite and MySQL, most of which a static indexer would never touch.

The honest comparison is therefore not about features, where the two lists overlap heavily, but about maintenance appetite. OLAINDEX is MIT licensed, publishes on Packagist, has a live demo at demo.olaindex.com and full documentation at wangningkai.github.io/OLAINDEX, and its last push was on 2026-04-23. If you want the tidiest possible static index and already run oneindex, the switch buys Laravel conventions rather than capability.

## Conclusion

OLAINDEX is a good fit when you have a OneDrive account holding files you want to hand out through a browser rather than a sharing link, and you are willing to run a PHP application yourself. It will not work without a Microsoft Graph account connection, and its short URL mode is a link shortener with a OneDrive backend rather than a general purpose one. Before deploying, resolve the PHP version question for yourself, because the README asks for 7.4 or newer, the Dockerfile is built on `php:7-cli-alpine`, and `.env.example` carries a note that Laravel 8 does not fully support PHP 8.4. Then check which branch you actually cloned, since the repository default is `dev` while the README's own license link points at `master`.

## FAQ

### What is OLAINDEX?

OLAINDEX is a OneDrive directory index application built on the Laravel framework and powered by the Microsoft Graph API. It turns a connected OneDrive account into a browsable site with file previews, password-protected directories and short sharing links.

### How do I install OLAINDEX?

Clone the repository, run `composer install` for the dependencies, then `composer run install-app` to initialize the Laravel application. The quick start also sets storage permissions with `chmod -R 755 storage` and `chown -R www:www *`, the latter of which assumes a Debian-style `www` user.

### What PHP version does OLAINDEX require?

The README asks for PHP >= 7.4 with OpenSSL, PDO, Mbstring, Tokenizer, XML, Ctype, JSON, BCMath and Fileinfo. The Dockerfile is built on `php:7-cli-alpine` with only `bcmath` installed, while `.env.example` disables deprecation reporting because Laravel 8 does not fully support PHP 8.4, so test on the version you plan to deploy.

### Is OLAINDEX still being updated?

The repository is not archived and the last push was on 2026-04-23, although the most recent GitHub release is v6.0 from 2020-12-31 and the two earlier releases are named with the word for archived. Commit history on the default branch is the better signal of currency than the release tags.

### How does OLAINDEX compare with oneindex?

OLAINDEX states that it was inspired by oneindex and shares the same premise of exposing OneDrive as a browsable directory. The difference is the base: OLAINDEX is a Laravel application with routing, migrations and `.env` configuration, while oneindex is standalone PHP, so the trade is Laravel conventions against a smaller maintenance surface.

### What license is OLAINDEX released under?

MIT. The README states that OLAINDEX is open-source software licensed under the MIT license, the repository contains a `LICENSE` file, and the project is published on Packagist as `wangningkai/olaindex`.

## Sources

- [License: MIT](https://github.com/WangNingkai/OLAINDEX/blob/dev/LICENSE)
- [Project website](https://OLAINDEX.JS.ORG)
- [README](https://github.com/WangNingkai/OLAINDEX/blob/dev/README.md)
- [Releases](https://github.com/WangNingkai/OLAINDEX/releases)
- [WangNingkai/OLAINDEX on GitHub](https://github.com/WangNingkai/OLAINDEX)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/wangningkai-olaindex