# Gephi: install, first use, and where the desktop graph tool stops > Gephi is a desktop OpenGL graph visualization platform for exploring networks up to a million elements. This covers how it installs, what the Netbeans module architecture means for extension, and the limits of the toolkit path. **gephi/gephi** — Gephi - The Open Graph Viz Platform - Repository: https://github.com/gephi/gephi - Website: http://gephi.org - Stars: 6,657 · Forks: 1,610 - Language: Java - License: GPL-3.0 - Published: 2026-09-22 · Updated: 2026-09-22 · Language: en - Canonical page: https://hysenlabs.com/projects/gephi-gephi ## What Gephi solves, and who actually needs it A network dataset is not readable as a table. Once you have more than a few hundred nodes, the structure that matters (communities, hubs, bridges between clusters) is only visible if you can lay the graph out and then interrogate it. Gephi exists for that step. The README describes it as an open-source platform for visualizing and manipulating large graphs, and the emphasis on manipulating is the part that separates it from a static plotting library: layout, filter and drag are interactive operations rather than a script you run and wait on. The intended user is an analyst, researcher or student who has a graph file and wants to look at it. The README points to example datasets on the wiki and a Quick Start guide, which tells you the project expects people to arrive with data and no prior knowledge of the internals. Developers are a second audience: the same README devotes a section to creating plug-ins that add a layout algorithm, a metric, a filter or a file format. Those two audiences get very different experiences from the same repository, and the split matters when you decide whether Gephi fits. ## The OpenGL engine and the Netbeans module architecture Two mechanisms define how Gephi works. The first is the rendering path. The README states Gephi is powered by a built-in OpenGL engine and that all actions such as layout, filter and drag run in real time, with networks up to a million elements. That is the architectural bet: instead of computing a layout once and drawing a static image, the application keeps the graph on the GPU and recomputes as you change parameters. It is why the interface is described as centered around the visualization. The second is the module structure. Gephi is built on top of the Apache Netbeans Platform and follows what the README calls a loosely-coupled, modular architecture, where modules depend on each other through APIs. The practical consequence is that the graph data model, the layout algorithms, the filters and the IO layer are separate modules, and a plug-in can reuse an existing API or replace a default implementation entirely. The repository layout reflects this: the top level holds a single pom.xml and a modules/ directory rather than one monolithic source tree. For anyone evaluating Gephi as a platform rather than a tool, that directory is the real documentation of what is separable from what is not. A third component is worth naming separately. The Gephi Toolkit packages essential modules (Graph, Layout, Filters, IO) as a standard Java library, and the README says it can be used on a server or command-line tool to do the same things Gephi does but automatically. It lives in its own repository, gephi-toolkit, and has its own download page. If your goal is automation, that is the artifact to look at, not the desktop build. ## Installing Gephi and loading a first dataset The README does not give install commands. It says to download and install Gephi, and links to gephi.org for the desktop download and to a separate install page. There is no package manager command in the repository, so the honest instruction is: get the installer for your platform from the project's download page, for Windows, Mac OS X or Linux. On Linux there are also flathub/ and snap/ directories at the top level of the repository, which indicates packaging manifests exist for those formats, but the README does not document how to use them. If you are building from source instead, the README is explicit about the toolchain: Java JDK 17 or later, and Apache Maven 3.6.3 or later. Clone your fork and build with the Maven wrapper the README shows: ```bash mvn -T 4 clean install ``` The -T 4 flag runs the build with four threads. To skip tests and shorten the build, the README documents a profile: ```bash mvn -T 4 clean install -P skipTests ``` Once the build finishes, the README gives the commands to launch the application from the application module: ```bash cd modules/application mvn nbm:cluster-app nbm:run-platform ``` One constraint is easy to miss and the README states it plainly: Gephi can be built with JDK 17 or later, but it currently requires JDK 17 to run. Building on a newer JDK does not mean you can run the result on one. For a first real use, the README directs you to the Quick Start and Tutorials pages and to sample datasets on the wiki. The workflow it implies is: download a dataset, load it, then start changing layout and filter settings and watch the view respond. That is the loop Gephi is designed around, and it is the fastest way to find out whether the OpenGL engine behaves acceptably on your hardware and your graph size. ## Where Gephi is the wrong tool The desktop application is a desktop application. The README positions the Toolkit separately precisely because the main product is not a batch processor: it is a Netbeans Platform application with a UI centered on visualization. If your requirement is a nightly job that reads a graph, computes metrics and writes results, running the desktop build is the wrong approach, and the README does not describe any headless mode for it. The scalability claim deserves careful reading. The README says Gephi can visualize networks up to a million elements, which is a statement about rendering, not about every algorithm you might run on that graph. Layout computation on a graph of that size is a different cost from drawing it. The README does not break down which operations stay interactive at which sizes, so treat the figure as a ceiling the project advertises rather than a guarantee for your particular analysis. There is also a version constraint that will bite in managed environments. Requiring JDK 17 specifically to run, while allowing newer JDKs to build, means a machine with only a newer JDK installed will not run the application as documented. That is a real deployment consideration for locked-down workstations, and it is stated in the README rather than buried. Finally, the documentation surface is split across several sites: the README, gephi.org, a docs site, a wiki and GitHub discussions. The README itself does not document rollback, upgrade paths between releases, or how to migrate a project file across versions. If those matter to you, they are not answered where you would first look. ## Gephi versus scripting the same analysis in Python The obvious alternative for network analysis is a Python graph library, where you write code that loads a graph, computes a layout and renders it. The difference in approach is not feature parity, it is where the loop lives. In a scripting environment you express the analysis as a sequence of calls and re-run the script when you change a parameter. In Gephi the parameter change is the interaction: you adjust a layout, apply a filter, drag nodes, and the OpenGL view updates. That makes Gephi better for the exploratory phase, where you do not yet know what question you are asking, and worse for the reproducible phase, where you want the same output every time from a checked-in script. The two are not mutually exclusive, and the Toolkit is the bridge. Because it packages the Graph, Layout, Filters and IO modules as a Java library, the same algorithms can be driven programmatically. If your team is Java-based, that is a coherent path: prototype in the desktop application, then move the settled parts into a Toolkit-based tool. If your team is Python-based, the Toolkit does not help you directly, and you are choosing between Gephi for exploration and a Python library for everything else. One more distinction is worth making. Gephi's plug-in architecture means the set of available layouts, metrics and import formats depends on which plug-ins are installed. A Python library's capabilities depend on which packages you imported. The failure modes differ: a missing Gephi plug-in is an installation problem you discover through the UI, while a missing Python package is an import error you discover immediately. ## Licence, releases and what maintenance costs you The licensing situation is not a single licence, and the README is careful about it. Gephi's main source code is distributed under a dual licence, CDDL 1.0 and GNU General Public License v3. The repository confirms this at the top level, where both cddl-1.0.txt and gpl-3.0.txt sit alongside LICENSE.md and COPYING.txt. There is also a separate licence for assets: the icons are licensed under CC BY 3.0 and live in the DesktopIcons module, organized by module name. If you redistribute Gephi or a build of it, the icon set carries its own attribution requirement distinct from the code licence. This is a description of what the repository states, not legal advice; the README links to Legal FAQs for the project's own reading of the dual licence. Upgrade cost is shaped by the JDK pin and the release cadence. The recent releases listed in the repository are v0.11.3, v0.11.2 and v0.11.1, and the README notes that development builds are generated regularly with a current version of 0.11.3-SNAPSHOT. Snapshots are published to a Maven snapshots repository with platform-specific artifacts for Windows, macOS on both x64 and aarch64, and Linux on x64 and aarch64. That is a wide build matrix, which is good for platform coverage and also means each release carries several artifacts to validate if you distribute internally. For plug-in developers the upgrade cost is the API surface. The README points to Javadoc for an overview of the APIs and to a Plugins Bootcamp for learning by example. Because plug-ins can replace default implementations, a plug-in that overrides a module's behaviour is coupled to that module's API in a way a plug-in that merely adds a layout is not. Pin your Gephi version, check the Javadoc at that version, and treat the snapshots as unsuitable for anything you depend on. ## Conclusion Adopt Gephi if you need to explore a network interactively and want a desktop application rather than a scripting environment: install from gephi.org, load a dataset from the wiki, and use the OpenGL view to move between layout, filter and drag in real time. Do not adopt it if your pipeline has to run unattended on a server, because the desktop application is not built for that and the Toolkit is a separate project with its own download. Before committing, verify two things: that your data fits the formats the IO modules accept, and that the JDK 17 requirement matches what you can install on the machines that will run it. The Toolkit's API surface is the part of this project most likely to change under you, so check the Javadoc for the version you pin. ## FAQ ### What is Gephi software used for? Gephi is used for visualizing and manipulating large graphs, with layout, filter and drag operations running interactively through a built-in OpenGL engine. The README also positions it as a platform developers can extend with plug-ins for new layouts, metrics, filters or file formats. ### Is Gephi free? Yes. The README states that Gephi's main source code is distributed under a dual licence, CDDL 1.0 and GNU General Public License v3, and the repository contains both licence files at the top level. The icons are separately licensed under CC BY 3.0. ### How do I install Gephi on my computer? The README says to download and install Gephi from the project's site, which offers builds for Windows, Mac OS X and Linux. It does not give command-line install steps, and it links to a separate install page and a Quick Start guide. ### How do I install Gephi on Linux? The README lists Linux among the supported platforms and points to the project's download and install pages rather than giving shell commands. The repository does contain flathub/ and snap/ directories, which indicates packaging manifests for those formats exist, but the README does not document how to use them. ### How do I use Gephi for network analysis? The README points to the Quick Start and Tutorials pages and to example datasets on the wiki. The intended workflow is to load a dataset and then adjust layout and filter settings while watching the OpenGL view respond in real time. ## Sources - [gephi/gephi on GitHub](https://github.com/gephi/gephi) - [License: GPL-3.0](https://github.com/gephi/gephi/blob/master/LICENSE) - [Project website](http://gephi.org) - [README](https://github.com/gephi/gephi/blob/master/README.md) - [Releases](https://github.com/gephi/gephi/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gephi-gephi