GNU Hyperbole 8.0.0, the Epiphany release, is now available worldwide

Overview GNU Hyperbole 8.0.0, the Epiphany release, is now available on GNU ELPA. Hyperbole is a unique hypertextual information management Emacs package that works across all Emacs modes, letting the computer do the hard work while you benefit from its sophisticated context-sensitive linking and navigation capabilities. Hyperbole has always been one of the best documented Emacs packages. With Version 8 comes excellent test coverage: over 200 automated tests to ensure quality. We hope you'll give it a try. What's new in this release is described here: [www.gnu.org/s/hyperbole/HY-NEWS.html](http://www.gnu.org/s/hyperbole/HY-NEWS.html) Everything back until release 7.1.3 is new since the last major release announcement (over a year ago), so updates are extensive. If you prefer video introductions, visit the videos linked to below; otherwise, skip to the next section. |GNU Hyperbole Videos|Web Link| |:-|:-| |Overview and Demo|[https://youtu.be/WKwZHSbHmPg](https://youtu.be/WKwZHSbHmPg)| |Quick Introduction|[https://youtu.be/K1MNUctggwI](https://youtu.be/K1MNUctggwI)| |Introduction to Buttons|[https://youtu.be/zoEht66N2PI](https://youtu.be/zoEht66N2PI) | |HyRolo, fast contact/hierarchical record viewer|[https://youtu.be/xdJGFdgKPFY](https://youtu.be/xdJGFdgKPFY)| |HyControl, fast Emacs frame and window manager|[https://youtu.be/M3-aMh1ccJk](https://youtu.be/M3-aMh1ccJk)| |Find/Web Search| [https://youtu.be/8lMlJed0-OM](https://youtu.be/8lMlJed0-OM) | Introduction Hyperbole is like Markdown for hypertext. Hyperbole automatically recognizes dozens of common patterns in any buffer regardless of mode and can instantly activate them as hyperbuttons with a single key: email addresses, URLs, grep -n outputs, programming backtraces, sequences of Emacs keys, programming identifiers, Texinfo and Info cross-references, Org links, Markdown links and on and on. All you do is load Hyperbole and then your text comes to life with no extra effort or complex formatting. Hyperbole interlinks all your working information within Emacs for fast access and editing, not just within special modes. Every button is automatically assigned a type and new types can be developed for your own buttons with simple function definitions. You can create your own buttons by simply dragging between two buffers. But Hyperbole is also a hub controller for your information supplying built-in capabilities of contact management/hierarchical record lookup, legal-numbered outlines with hyperlinkable views and a unique window and frame manager. It is even Org-compatible so you can use all of Org's capabilities together with Hyperbole. Hyperbole is unique, powerful, extensively documented, and free. Like Emacs, Org, Counsel and Helm, Hyperbole has many different uses all based around the theme of reducing cognitive load and improving your everyday information management. It reduces cognitive load by using a single Action Key, {M-RET}, across many different contexts which automatically chooses the best action Then as you grow with it across time, it helps you build new capabilities that continue to speed your work. Installing and Using Hyperbole To install within GNU Emacs, use: {M-x package-install RET hyperbole RET} Hyperbole installs in less than a minute and can be uninstalled even faster if ever need be. Give it a try. Then to invoke its minibuffer menu, use: {C-h h} or {M-x hyperbole RET} The best way to get a feel for many of its capabilities is to invoke the all new, interactive DEMO and explore sections of interest: {C-h h d d} To permanently activate Hyperbole in your Emacs initialization file, add the line: (hyperbole-mode 1) Hyperbole is a minor mode that may be disabled at any time with: {C-u 0 hyperbole-mode RET} The Hyperbole home page with screenshots is here: [www.gnu.org/s/hyperbole](http://www.gnu.org/s/hyperbole) For use cases, see: [www.gnu.org/s/hyperbole/HY-WHY.html](http://www.gnu.org/s/hyperbole/HY-WHY.html) For what users think about Hyperbole, see: [www.gnu.org/s/hyperbole/hyperbole.html#user-quotes](http://www.gnu.org/s/hyperbole/hyperbole.html#user-quotes) Enjoy, The Hyperbole Team

Nice. Thanks for sharing

I installed 8.0 on Emacs 28.1 from gnu's ELPA repository and every time I start Emacs, I have this message: Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hbdata.el: Error: Symbol's value as variable is void hyperb:microsoft-os-p Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hui-em-but.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hui-mouse.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hbut.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hactypes.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hsys-www.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hibtypes.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hypb-ert.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hib-social.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hib-debbugs.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hib-kbd.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/kotl/klink.el: Error: Symbol's function definition is void var:append Disable showing Disable logging Warning (comp): ~/.emacs.d/elpa/hyperbole-8.0.0/hib-doc-id.el: Error: Symbol's function definition is void var:append Disable showing Disable logging

That's an error during native-compilation, specifically. You're getting it each time because it fails to compile those libraries each time (and it tries each time because they're not yet compiled). I can replicate this with a native-compilation build.

Sorry for this. We are looking into it and will provide a resolution in about a day. It looks like the dynamically generated autoloads which define var:append from hvar.el are not being loaded before compilation.

Yes, it seems the native compilation is running prior to loading the necessary package autoloads. See if you can force a load of "hyperbole-autoloads.el" before native compilation is invoked and that may resolve it.

Great to see org-mode integrations! Cheers, awesome project.

> available **worldwide** Did someone ever heard about some Open-Source-Software that was only available in, say, Sicilia?

Hyperbole, epiphany, worldwide - its all tongue-in-cheek to put a smile on your face. While the software makes things so easy that it does the same.

Excellent -- I've been messing with the in-development code for a few months, and there's been a ton of improvements. Virtually all of the issues and annoyances I had with the 7.x.x release have been fixed or cleaned up, and there's a lot of good, new stuff in there. Looking forward to really going through everything!

If you use Org mode you don't need Hyperbole. Org links can be used in arbitrary major modes with org-open-at-point-global. "Buttons" to interlink different files are nor an interesting nor a unique concept of Hyperbole. Also it has often been criticized that Hyperbole throws together too many unrelated concepts, see https://github.com/rswgnu/hyperbole/issues/6. Essentially every time I read about Hyperbole it is hyperbolically oversold.

https://github.com/rswgnu/hyperbole/issues/44

Hey, no worries, just wanted to report it :D

Dude, we know no one cares about our pet projects nor will pay us for our efforts. Show-and-tell is all we emacs devs have. All we ask is for the public to avoid taking a dump on our finger painting.

Sorry.....Hyperbole is indeed the best project. It is the one missing piece in Emacs. Its worldwide interlinking capabilities are unmatched by even the most advanced AIs. Thanks to Hyperbole we are not only one step, but at least three steps closer to singularity. And it is even Org-compatible!1!!

Whoa, the demo lost me when I skipped around to see what's going on and I was looking at a dozen splits :) https://imgur.com/a/xWlM19N Need to take this in slowly.

You found the wonderful windows grid feature that gives you a rapid grid layout of windows containing a set of buffers of interest or most recently used ones. Use {C-h h h} the history command to restore your frame to its previous state and return to the demo.

Hyperbole and Org mode are so different, it always amazes me when people try to decide on one or the other. Now they are highly compatible and you can use the features from each package that you like and even use them together in the same buffer where needed. Both packages do much more than linking and almost all of those additional features are significantly different.

Always nice to give people a laugh. Now that we have dozens of users, world domination can't be far off.

Maybe I really don't get Hyperbole? I use Org (the outliner, markup, agenda, linking, babel, ...). For global linking/"buttons" Org seems to give me all I need. I don't need the Koutliner, Hyrolo or Hycontrol. What else is in there for us Org users then? I see that Hyperbole has implicit buttons which are automatically recognized. I would probably use those rarely given that I can open paths and urls with ffap. For other link types I would rather use explicit Org links.

Hyperbole will soon swallow Hypemacs, the entire Hypergnule project and we will all get our Hypertransplants! Only this one small village of indomitable Orgs still holds out against the overpowering Hyperbole.

So there you go. You are happy with your existing toolset and don't feel a need for another. But many other people may need help in leveraging more of Emacs' capabilities and Hyperbole's implicit buttons really help in this regard since there is little to learn other than that you press {M-RET} in a context likely to display something and Hyperbole performs a useful function in response. (Try it on a pathname output from "echo $PATH" in a shell, for example). Some people need the fast hierarchical record lookup that HyRolo provides without needing any database indexing backend. Some people like the dynamic, legal-numbering outlining capability of the Koutliner or the ability to link right to an individual cell without using hidden or long IDs. Or the single command that exports such outlines to HTML and allows expanding and collapsing trees within a web browser. Or the fast frame and window controller that let's you automate your Emacs screen layouts very easily. The ease of linking to git, GitHub and Gitlab artifacts is likely unparalleled. And the list goes on. The point is to give you a ton of fast access to information out-of-the-box without you having to do much of anything or to see ugly markup throughout your buffers just to gain structure. Hyperbole also has a great set of examples of Elisp throughout its code that you can reference to learn useful programming techniques if you are not yet an advanced Elisp programmer. So there may be some value for people who want to expand their Emacs toolset.

I tried to use hyperbole a few times but I was not getting it. With this post with various links and videos I am now starting to understand it and I'm looking forward to integrating it into my workflows. Thanks!

I disagree with this as I use both and they complement each other nicely. This release should have them playing nicely together.

A hyperbole feature (documentation?) request: create a supported way to create new implicit buttons. Inspiration: https://gnu.org/software/emacs/manual/html_node/emacs/Bug-Reference.html.

Great, glad to hear it. We know that some of the concepts are a bit different but if you find any specifics that you think are barriers to picking it up, feel free to let us know.

There are many types of implicit buttons, each type has its own format. Some have delimiters, some don’t. Action Buttons are a generalized form of implicit buttons that can execute other implicit button types but always appear delimited by angle brackets. If you want a standard way of creating new implicit button types, that is documented in the Hyperbole manual. Since the textual form of different types varies, there can be no single way of creating them other than typing them in your text. We could create a way of inserting a name for an implicit button if typing the <[name]> delimiters is problematic. Remember implicit buttons should naturally appear as part of your text so you should be able to type them easily. If you provide a simple example of what you want, maybe we can help you further.

By the way, Hyperbole already supports Emacs bug reference hyperlinks out of the box if you load the debbugs package before using Hyperbole. Then just Action Key press on a bug#123345 reference to display the bug report and discussion in GNUS.

It's such an obvious thing that I figured it existed and checked the docs but I couldn't find anything. I guess I didn't know what to search for.

There is a manual section: https://www.gnu.org/software/hyperbole/man/hyperbole.html#Creating-Implicit-Button-Types

I have a problem with understanding of implicit/explicit/global buttons. Are following analogies true? 1. implicit = implemented patterns in hyperbole and interpreted automatically (e.g. files, urls, etc) 2. explicit = strings with special syntax to describe what to do (e.g. run some action, key-sequences, etc) 3. global = it is some file with list of buttons, kind of bookmarks.

You are pretty close though a bit off on #2, explicit. Here's a general explanation of Hyperbole buttons which has to be a bit technical for you to see the generality of each kind. Use the Hyperbole DEMO, {C-h h d d}, to understand what they can do. Action types are Lisp macros that expand into Lisp functions to perform specific parameterized actions for any category of Hyperbole button. There are 3 categories of Hyperbole buttons: explicit, global and implicit and any action type can be utilized as part of any category of button. Explicit buttons (ebuts) are explicitly created and inserted into buffers together with a button type and associated arguments (button metadata stored in a separate file). All such buttons are surrounded by <( )> delimiters. Each ebut type can utilize any action type(s) and can be used by any number of explicit buttons. So rather than just link buttons, you can have weather reporting buttons, etc. but you have to create each one individually using Hyperbole or write a program to do so. Implicit buttons (ibuts) are natural patterns within buffer text recognized by Hyperbole's implicit button type matcher. Each pattern is matched by an implicit button type using arbitrary Lisp code. This type specifies the pattern to match and the action type to execute, e.g. match to Texinfo cross-references and display the associated Info node or index entry. A single implicit button type definition allows you to follow an infinite number of implicit buttons recognized within text without doing anything else as there is nothing more to an implicit button than its textual pattern; it is just text with Hyperbole automatically generating its metadata ({C-h A} when atop an implicit button) on the fly. You can augment an implicit button with a preceding name surrounded by the <\[ \]> delimiters, e.g. <\[Hyperbole News\]>: {C-h h d n}. Global buttons (gbuts) are simply explicit or named implicit buttons that are stored in a user's 'personal button file' (like a Hyperbole home page accessed with {C-h h b p}). Global buttons can be accessed by name from any buffer (like bookmarks with actions) by using {C-h h g a}. With a few quick keystrokes, you can automate any of the Emacs tasks you do frequently or display frequently referenced information. This is the full generality of Hyperbole buttons, but a user need not know all this. Just study the types of builtin implicit buttons as documented in the manual and then press {M-RET} or use the keyboard-driven Hyperbole minibuffer menu to create and activate explicit or global buttons. For implicit buttons, just type out the desired text pattern in a buffer.

This appears to be an issue with the nativecomp integration with Emacs not loading the hyperbole-autoloads.el file prior to native compilation; we'll file an Emacs bug report and see what happens.

I know this is a few weeks late, but thank you for the package! I essentially had this in my tabs waiting until I could learn a bit about Hyperbole. One thing I would really like to see is a better tutorial/demo. I know the Emacs community is kinda partial to having documentation that is just a big wall of text, but that does turn a lot of people off. I hope to start working on a more interactive tutorial soon, if that's something you would be interested in?

That sounds like a great idea. Although we have the DEMOs and one for the Koutliner, plus a few videos, there is no tutorial that gently guides you through all of Hyperbole’s features. Why not take a first pass and then reach out for feedback. Look forward to seeing it.

Perfect! I am going on a vacation for all of next week (camping so no real use of electronics), so hopefully I will get something basic up before then, but if not then the week after! Also, I read through the Koutliner example and think that was great and read through most of it.

Keep at it and do great things.

Eli, the head maintainer of Emacs, seems to feel that the native compiler need not connect with the package manager, so there is no need to ensure that package autoloads are loaded by the package manager prior to an asynchronous run of the native compiler. He suggests treating the autoloads like loaddefs and having each Lisp library either require or load the loaddefs file. We will work on this for the next release.

Hi: Any progress on this you care to show?

Glad to hear it. Let us know how you end up using it.

I have a bit of progress, would you like me to send it to the email listed in the FAST-DEMO?

Sure. Thanks.

We fixed this native compilation problem a god while back in the pre-release master tip of Hyperbole but have not yet made a new release. It simply requires a change in the Makefile, if you can manually build Hyperbole yourself after installation. Simply replace the Makefile 'eln' target with the text between the ----- lines: \-------- \# Create -l "file.el" load-file command-line args for each Hyperbole .el file for use in \# eln native compile target below. LOAD\_EL = $(shell echo "$(EL\_KOTL) $(EL\_COMPILE)" | sed - -e 's+ +" -l "./+g' -e 's+\^+-l "+')" load-hyperbole: $(EMACS\_BATCH) \\ $(LOAD\_EL) eln: src $(EMACS\_BATCH) \\ $(LOAD\_EL) \\ \--eval="(setq-default byte-compile-warnings '(not docstrings))" \\ \-f batch-native-compile $(EL\_KOTL) $(EL\_COMPILE) \---------- Save the Makefile and then in a bash-like shell, type 'make eln' to natively compile it. There should be a new release later this year.