简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Glue?
Glue is a Python library for exploring relationships within and among related datasets. Its core idea is linked statistical graphics: you make scatter plots, histograms, and 2D or 3D images, then brush (select) points in one view and watch that selection propagate to every other view. On top of that, Glue lets you define logical links between different datasets, so data from separate files or tables can be overlaid and selected together.
The documentation presents it as a tool that blurs the line between GUI-centric and code-centric work. You can use the graphical application without writing code, or drive it from Python in several ways: through the built-in IPython terminal, by sending NumPy arrays or Pandas DataFrames into Glue for exploration, or by customizing your setup with config.py files to auto-load and clean data, parse custom file formats, define custom links, or build your own data viewers. Because it is written in Python and built on NumPy, Matplotlib, and SciPy, your own input, cleaning, and analysis code can be integrated directly.
Who it suits
- Analysts and scientists with multi-file datasets who need to see how variables in one table relate to another, rather than viewing each dataset in isolation.
- Python users who want interactive exploration but do not want to leave their scripting environment, or who want to script the parts that repeat.
- Developers who want to reuse Glue's data-linking framework inside their own application, or package plugins for distribution.
A practical scenario
Suppose you have one table of galaxy measurements and a second table of simulation outputs, and you want to check whether the same objects behave consistently in both. A general-purpose plotting tool would show you two charts side by side; Glue's linking model lets you select a region in one chart and see which rows in the other dataset correspond, provided you have told it how the two datasets are related. That link definition is the step worth planning first, since the value of the linked views depends on it.
Trade-offs to weigh
Glue's flexibility is also its main cost. The linking between datasets is user-specified and arbitrarily configurable, which means someone has to decide what the links are and set them up. For a single dataset with a few columns, a simpler plotting library may get you to an answer faster. Glue earns its place when you have several related datasets and your questions involve moving back and forth between them.
Next step
Start with the documentation's Getting started and Using the Glue application sections to see the graphical workflow, then read Interacting with data from Python if you want to feed in arrays or DataFrames. If your work is in a specific domain, the domain-specific guides are the fastest route to relevant examples. The official documentation is at Glue Documentation.
How do I get started with Glue if I don't want to code?
Use the graphical Glue application on its own: the documentation states you can work with it "as is, and never type a line of code." Everything you do in a no-code session follows the same pattern — load datasets, create scatter plots, histograms or 2D/3D images, then brush (select) points in one view and watch the selection propagate to the others.
A concrete first session
- Load your data. Glue is built for exploring relationships within and among related datasets, so start with one file or a small set of files that share an identifier column (for example, the same object IDs in a table and in an image cube).
- Create a view per dataset. Open a scatter plot for the table and an image view for the cube. The scatter plot shows how two columns relate; the image shows spatial structure.
- Link the datasets. This is the step that distinguishes Glue from a plain plotting tool. You tell Glue which attributes correspond between datasets — the docs call these links "specified by the user, and are arbitrarily flexible." Once linked, an overlay of one dataset appears on the other.
- Brush and follow the selection. Drag a selection in the scatter plot. Because of the brushing-and-linking paradigm, that selection propagates to every other view, including the linked dataset. This is how you answer questions like "where in the image do the outliers in this column live?"
- Iterate. Add a histogram to see the distribution behind your selection, or a second scatter plot to compare two relationships at once.
When the no-code path is enough, and when it is not
| Situation | No-code GUI | Needs Python |
|---|---|---|
| Standard file formats and quick exploration | Good fit | Unnecessary |
| Brushing and linking across a few related datasets | The core strength | Unnecessary |
| A file format Glue does not read natively | Blocked | Custom parser needed |
| Repeated, scripted cleanup before every session | Manual each time | Automate via configuration |
| Building a reusable plugin or embedding linking in your own app | Not possible | Required |
The trade-off is straightforward: the GUI gives you fast, visual iteration with no setup, but anything the application does not already support — an unusual file format, automatic pre-cleaning, a bespoke viewer — is where the documentation points you toward Python. You do not have to cross that line all at once. The application contains a built-in IPython terminal, so you can stay in the graphical workflow and drop into code only for the one step that needs it.
Next step
Read the "Getting started" and "Using the Glue application" sections of the official documentation at Glue Documentation, which are organised exactly along this no-code-first path. If you later want to see how Glue differs from other visualization tools before committing, the documentation links its own comparison table; the deciding question is usually whether your workflow depends on linked selections across multiple datasets, since that is the capability Glue is built around.
How can I use Glue from a Python or IPython session to explore my data?
You can hand data straight from a Python or IPython session to Glue and keep exploring it through Glue's linked graphics, rather than saving files and re-importing them. The documentation describes several routes: the graphical application with its built-in IPython terminal, sending NumPy arrays or Pandas DataFrames into Glue for exploration, and customizing your setup through config.py files.
The practical options
- Built-in IPython terminal. Start the Glue application and use its embedded IPython terminal, so you can inspect and manipulate data in the same session that drives the visualizations.
- Push arrays or DataFrames to Glue. From your own Python or IPython session, send NumPy arrays or Pandas DataFrames to Glue for exploration. This suits data you have already loaded, filtered or derived in code.
- Customize via
config.py. Use configuration files to automatically load and clean data before Glue starts, write custom parsers for your file format, define custom linking functions between datasets, or create your own data viewers.
How to choose
| Your situation | Better starting point |
|---|---|
| Data lives in files in a format Glue does not read | Custom parser in config.py |
| Data is already a NumPy array or DataFrame in your session | Send it directly to Glue |
| You want to tweak selections and see them propagate immediately | Glue application, using its IPython terminal |
| You need repeatable setup each time you launch | config.py for automatic loading and cleaning |
The payoff of the Python route is that selections and links stay live: Glue's brushing-and-linking model propagates a selection made in one scatter plot, histogram or image to the others, and logical links between related datasets let you overlay and cross-select them. Doing the loading, cleaning and linking in Python means that behaviour is reproducible rather than re-created by hand.
A concrete first session
Load a table with Pandas, trim the columns you care about, then send the resulting DataFrame to Glue and build a scatter plot plus a histogram. Brush a cluster in the scatter plot and watch the histogram update. If you repeat this workflow often, move the loading and cleaning steps into a config.py so Glue starts with your data ready.
For the exact function names and call signatures, work through the "Interacting with data from Python" and "Getting started" sections of the Glue Documentation. If you also want to see where Glue sits relative to other tools before committing, the project's own comparison table is linked from that documentation.
How do I customize or hack Glue for my own data formats and workflows?
Glue is built so you can extend it without forking it. The documentation describes customization through config.py files and, for larger efforts, separate plugin packages. The usual path is to start with a config file for quick, personal tweaks, then move to a plugin package when you want to share your format readers, data links or viewers with others.
What you can customize
- Data loading: write a custom function that parses your file format and hands data to Glue, so your format appears alongside the built-in loaders.
- Linking: define custom link functions that tell Glue how rows in one dataset correspond to rows in another, which drives selection propagation and overlays.
- Viewers: create your own data viewers when scatter plots, histograms and 2D/3D images don't express what you need.
- Startup behavior: use
config.pyto automatically load and clean data before Glue starts, so a session opens ready to explore. - Distribution: package your additions as a plugin so other users can install them separately.
Choosing between config files and plugins
| Approach | Best for | Trade-off |
|---|---|---|
config.py customization |
Personal or lab-specific formats, quick iteration | Tied to your setup; harder to share cleanly |
| Plugin package | Reusable readers, links or viewers for a team or community | More structure and maintenance, but distributable |
A concrete workflow
A scientist with a proprietary instrument format can write a loader function in config.py, register a link between the instrument's sample IDs and a reference table, and have both datasets open and linked at startup. When colleagues need the same capability, the loader and link move into a plugin package.
For the full API and step-by-step guidance, see Glue Documentation. If you want to see how Glue's approach compares with other tools before committing to an extension, the docs point to a comparison table and a videos page.
How can I develop a plugin or use the Glue framework in my own application?
Glue is designed to be extended. The documentation separates two related paths: building a plugin package that you distribute to users, and embedding Glue's data-linking framework inside your own application. Both are supported through the same core Python library, which is built on NumPy, Matplotlib and SciPy.
Developing a plugin
A plugin is the route when you want Glue users to install your functionality alongside the main application. The documentation lists several extension points you can hook into:
- Custom data viewers, if your data needs a visualization Glue does not provide.
- Custom file parsers, so Glue can load your preferred file format directly.
- Custom linking functions, to define how datasets should be linked when automatic linking is not enough.
- Configuration through
config.pyfiles, which can also load and clean data before Glue starts.
The practical workflow is to write these components against Glue's Python API, package them, and distribute the package separately from Glue itself. Start by reading the "Developing Glue" and "Customizing/Hacking Glue" sections of the documentation, then look at the API reference for the classes your plugin will subclass. Testing against the current release matters because extension APIs can change between versions.
Using the Glue framework in your own application
Glue's framework is not limited to its own GUI. The documentation states that you can use it in your own application to provide data-linking capabilities. That means your application keeps its own interface, while Glue supplies the logic for linking datasets and propagating selections.
This is a heavier commitment than writing a plugin, because you take responsibility for integrating Glue's data model and linking machinery into your application's architecture. It is most sensible when linked selection across datasets is a central feature of your tool, rather than something you could approximate with a few callbacks.
Choosing between the two
| Goal | Approach | Main trade-off |
|---|---|---|
| Add viewers, parsers or linking rules for Glue users | Plugin package | Must track Glue's extension API across releases |
| Add data-linking to your own product | Embed the framework | More integration work; you own the application layer |
| Just explore data interactively | Use the Glue application or its built-in IPython terminal | No distribution or integration work |
A practical next step
If you are unsure which path fits, prototype the smallest possible version first: a single custom viewer or parser loaded through a config.py file. That exercises the same API surface a full plugin would use, without committing you to packaging or to embedding the framework. If the prototype needs to reach beyond Glue's own interface, embedding is probably the better fit. The official documentation is at Glue Documentation.
How does Glue compare to other open-source and commercial data visualization tools?
Glue sits in a particular niche: it is built for exploring relationships within and among related datasets, not for producing polished charts for publication. Its defining feature is the brushing-and-linking paradigm, where a selection in one plot propagates to every other plot, and its ability to link datasets through logical relationships the user defines. That combination is what separates it from general-purpose plotting libraries and from most commercial dashboard tools.
Where Glue differs
| Tool type | Typical strength | Typical gap for Glue-style work |
|---|---|---|
| General plotting libraries (Matplotlib, etc.) | Precise, scriptable, publication-quality figures | No built-in interactive selection linking across many plots |
| Statistical/notebook environments | Fast iteration in code, rich ecosystem | Linked brushing across multiple datasets is not the core model |
| Commercial BI/dashboard tools | Sharing, governance, scheduled refresh | Weaker for arbitrary scientific data structures and custom linking logic |
| Glue | Linked statistical graphics across related datasets, with Python extensibility | Less oriented toward dashboards, sharing, or print-ready output |
The practical trade-off: if your question is "how do these two measurements relate, and does that relationship hold in this subset of my other dataset?", Glue's model fits directly. If your question is "how do I publish this figure?" or "how do I give 200 colleagues a dashboard?", Glue is usually the wrong tool.
A concrete scenario
Imagine three files from one observing run: a catalogue of sources, a table of measured fluxes, and an image cube. In a general plotting library you would write code to join them and produce separate figures. In Glue you load all three, define how rows in the catalogue correspond to positions in the image, then brush a region in the image and watch the corresponding points highlight in the scatter plot and histogram. That interactive loop is the product's reason for existing.
How to decide
- Choose Glue when your data is multi-dimensional, multi-file, and you need to find structure rather than present it.
- Choose a general plotting library when you already know what the figure should look like.
- Choose a BI tool when distribution and repeatability matter more than exploratory flexibility.
Glue also blurs the GUI/code boundary: you can drive it from Python, send in NumPy arrays or Pandas DataFrames, and extend it through configuration files, custom file parsers, custom linking functions, or your own data viewers. That matters if your workflow is partly scripted and partly visual.
A useful next step is to take one dataset you already understand well, load it in two or three different tools, and try to answer a question that requires selecting a subset in one view and seeing it in another. The tool that makes that loop fastest is the one worth adopting. The official documentation at Glue Documentation covers the getting-started paths, the Python interaction route, and domain-specific guides, and it points to a comparison table against other open-source and commercial visualization solutions.
GoDaddy
Cloudflare
User reviews (0)