# JanusVLN gives a vision-language agent two memories instead of one

> JanusVLN is the ICLR 2026 research code for vision-language navigation with a dual implicit memory, one for semantics and one for spatial structure. The repository is a research release with weights, trajectory data and training and evaluation scripts, and the setup it expects is a full Habitat simulator stack.

**MIV-XJTU/JanusVLN** — [ICLR2026] Official implementation for "JanusVLN: Decoupling Semantics and Spatiality with Dual Implicit Memory for Vision-Language Navigation"

- Repository: https://github.com/MIV-XJTU/JanusVLN
- Website: https://miv-xjtu.github.io/JanusVLN.github.io/
- Stars: 602 · Forks: 39
- Language: Python
- License: not declared
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/miv-xjtu-janusvln

## Two memories, one for meaning and one for place

JanusVLN is a vision-language navigation framework and the documentation claims it is the first to feature a dual implicit memory. The name comes from the Roman god with two faces, and the stated inspiration is the implicit scene representation in human navigation, which integrates left-brain semantic understanding with right-brain spatial cognition.

From that idea the framework constructs two complementary, fixed-size, compact neural memories. One carries semantics, the other carries spatial structure, and neither grows with the length of the trajectory. That fixed-size property is what makes it a memory rather than a context buffer.

The stated ambition is to steer vision-language navigation research from what the documentation calls 2D semantics-dominant work toward 3D spatial-semantic synergy, described as a critical direction for next-generation spatial embodied agents.

The paper is on arXiv at 2509.22548, the project has a page hosted under the miv-xjtu GitHub Pages site, and the authors are from Amap, Alibaba Group and Xi'an Jiaotong University. Shuang Zeng, Dekang Qi, Xinyuan Chang, Feng Xiong, Shichao Xie, Xiaolong Wu, Shiyi Liang, Mu Xu and Xing Wei are listed as the authors.

So the audience is a research group in embodied AI. This is not a library you drop into a product, and the install instructions make that clear before you read a line of the paper.

## The install expects Python 3.9, Habitat and a specific CUDA build

The documented environment is pinned tightly, and the steps are the first thing to read if you are evaluating the project.

```bash
git clone https://github.com/MIV-XJTU/JanusVLN.git && cd JanusVLN

conda create -n janusvln python=3.9 -y && conda activate janusvln

conda install habitat-sim==0.2.4 withbullet headless -c conda-forge -c aihabitat
```

The simulator is the heavy part. habitat-sim is pinned to 0.2.4 and installed headless, which is the right choice on a machine without a display, and it comes from the conda-forge and aihabitat channels. Then the Habitat lab and baselines are checked out and installed in editable mode:

```bash
git clone --branch v0.2.4 https://github.com/facebookresearch/habitat-lab.git
cd habitat-lab
pip install -e habitat-lab
pip install -e habitat-baselines
cd ..
```

The torch build is pinned to the CUDA 12.4 wheel index:

```bash
pip install torch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1 --index-url https://download.pytorch.org/whl/cu124
```

and the project itself is installed last, from requirements.txt and then in editable mode:

```bash
pip install -r requirements.txt
# Install JanusVLN
pip install -e .
```

The requirements list shows what the project expects to pull in: transformers pinned at 4.50.0, flash-attn, deepspeed, accelerate, peft, timm, datasets, decord, torchcodec, wandb, loguru and qwen_vl_utils among others. The presence of flash-attn, deepspeed and peft tells you this is a training-oriented setup rather than an inference-only one.

A tutorial document was added on 2026-8-17 covering three ways to use the project: Conda, Skill with Conda, and Docker. If Docker is your preference, that document is the file to read first.

## Scene datasets and episodes that you have to assemble yourself

Data preparation is a multi-stage job, and nothing is bundled.

The scene datasets come from the original sources. For R2R and RxR you download the MP3D scenes from the official Matterport project page and place them under data/scene_datasets/mp3d/. For ScaleVLN you download the HM3D scenes from the official GitHub page and place the train split under data/scene_datasets/hm3d/.

The VLN-CE episodes are separate downloads that get extracted into data/datasets/. The R2R archive needs renaming from R2R_VLNCE_v1-3_preprocessed/ to r2r/, and the RxR archive from RxR_VLNCE_v0/ to rxr/. For ScaleVLN, the documentation points at a 150k subset and tells you to follow StreamVLN to convert it into the VLN-CE format.

Then there is the trajectory data, which the project does provide. Pre-collected observation-action trajectories for training are available, with R2R and RxR collected following VLN-CE and ScaleVLN following StreamVLN. DAgger data is collected using JanusVLN_Base, and the documentation advises that it is best to collect DAgger data using your own base model. The archives go to data/trajectory_data/ and data/dagger_data/.

The documented folder layout shows how the pieces fit together, with data/datasets/ holding r2r, rxr and scalevln, data/scene_datasets/ holding hm3d and mp3d, and the trajectory and dagger directories each carrying an images folder and an annotations.json. The scale of the scene download is the thing to plan for: this is gigabytes of 3D assets before any training starts.

## Building the dataset index is a script, then a manual config edit

After the data is in place, the base dataset is constructed with a single script:

```bash
python create_data/create_data.py
```

The documentation says this constructs a base dataset that only includes R2R-CE and RxR-CE, which tells you something about the pipeline's assumptions: those two are the primary benchmarks, and ScaleVLN is added afterwards through its own conversion path.

There is a manual step after the script, and it is the kind that trips people up. The dataset information needs to be configured in the file src/qwen_vl/data/__init__.py. Nothing automates it, so the paths your run will use are set by editing a Python source file in the package.

The naming of that path is itself informative. The src directory contains a qwen_vl package, so the vision-language backbone is built around a Qwen-VL style model, and the configuration file lives inside that package where the data loading code can read it.

The repository layout shows the rest of the structure: a config directory, the create_data directory with the script, a scripts directory for the training and evaluation entry points, a src directory, a tutorial directory, assets with the logo and overview image, and a setup.py that declares the package as JanusVLN version 0.1.0 with find_packages rooted at src and an empty install_requires, since the real dependencies are pinned in requirements.txt instead.

## Two model checkpoints, and a weights correction worth knowing about

The Model Zoo section of the documentation is where the released artefacts are listed, and there is a correction note attached to them.

Two checkpoints are published on ModelScope: JanusVLN_Base and JanusVLN_Extra. The Base model is also the one used to collect the DAgger data, which is why the documentation suggests using your own base model for that step rather than the released one.

The correction matters. A news entry from 2025-11-06 states that due to a previous upload of incorrect weights for the JanusVLN_Extra model, anyone who needs to run inference directly should download the correct weights from the JanusVLN_Extra page again. That is the kind of note that saves an afternoon of debugging a model that produces nonsense, and it also means you should check the model card rather than assume a cached download is the right artefact.

Trajectory data is published on ModelScope as well, under JanusVLN_Trajectory_Data, which is the same dataset referenced in the data preparation steps.

A live demo video is linked from the header, and the repository also carries a CHANGELOG-style news list with three entries: the tutorial release on 2026-8-17, the ICLR 2026 acceptance on 2026-1-26, and the weights correction on 2025-11-06. There are no GitHub releases, so the ModelScope pages are the distribution channel for the model files.

## What the repository does not settle for you

Several things a adopter will want are simply not in the documentation, and it is better to name them than to infer them.

There is no licence file listed among the top-level repository entries, and the licence field is unknown. The code is a research artefact from a company and a university, and the weights sit on ModelScope under their own terms, so if you intend to build on this you need to ask the authors directly. This is not a legal opinion, just the observation that the permission is not in the repository.

The documentation also stops before the training and evaluation details in what is visible here. The table of contents lists Training, Evaluation, Tutorial and Citing sections, and the scripts directory exists, but the specific training commands, the hyperparameters and the evaluation protocol are in the part of the readme that is not shown here, and there are separate how-to documents under the tutorial directory.

The dependency set is also heavy for a research codebase. flash-attn needs a matching CUDA and compiler toolchain, deepspeed assumes a distributed training setup, and torchcodec and decord both need their own system libraries. The tutorial document that covers the Docker route exists precisely because this environment is not simple.

The third limitation is about the research claim itself. The documentation frames dual implicit memory as a first, and steers the field toward 3D spatial-semantic synergy. Whether a two-memory design beats a single fused memory on your task is an empirical question the repository is set up to answer rather than one it settles for you.

## Conclusion

JanusVLN suits a research group working on vision-language navigation who wants to build on a published dual memory design rather than a single fused memory, and who can afford the Habitat simulator and scene dataset setup the scripts expect. It is the wrong tool for anyone wanting a runnable navigation demo, since the installation pins Python 3.9, a specific Habitat version and CUDA 12.4, and it is the wrong tool for a product deployment because the licence is not stated in the repository. Before building on it, read the tutorial document for the Conda, Skill with Conda and Docker routes, and confirm the licence terms with the authors, since the repository lists no licence file and the weights are hosted separately on ModelScope.

## FAQ

### What is JanusVLN and what is the dual implicit memory?

JanusVLN is a vision-language navigation framework, the official implementation for the ICLR 2026 paper JanusVLN: Decoupling Semantics and Spatiality with Dual Implicit Memory for Vision-Language Navigation. The documentation describes it as the first VLN framework to feature a dual implicit memory, two complementary, fixed-size, compact neural memories inspired by how human navigation integrates semantic understanding with spatial cognition.

### How do I install JanusVLN?

The documented steps clone the repository, create a conda environment with Python 3.9, install habitat-sim 0.2.4 headless from conda-forge and aihabitat, install habitat-lab and habitat-baselines in editable mode, install torch 2.5.1 with the CUDA 12.4 wheel index, then run pip install -r requirements.txt and pip install -e . . A tutorial document added on 2026-8-17 also covers Conda, Skill with Conda and Docker routes.

### Where do the JanusVLN model weights and training data come from?

Both the JanusVLN_Base and JanusVLN_Extra checkpoints and the pre-collected trajectory data are hosted on ModelScope. The documentation notes that incorrect weights were previously uploaded for JanusVLN_Extra, so if you need to run inference directly you should download the correct weights from the JanusVLN_Extra page again.

## Sources

- [Issues](https://github.com/MIV-XJTU/JanusVLN/issues)
- [MIV-XJTU/JanusVLN on GitHub](https://github.com/MIV-XJTU/JanusVLN)
- [Project website](https://miv-xjtu.github.io/JanusVLN.github.io/)
- [README](https://github.com/MIV-XJTU/JanusVLN/blob/main/README.md)

---

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