Hog Bay Software

Mac: Where is Save As?

2025-12-12T00:00:00Z

I’m often asked why Save As… is missing from my apps.

It isn’t gone, but it has been de-emphasized in favor of the new Auto Save + Versions system. This change isn’t specific to my apps—it’s part of the macOS platform.

History: Save As, Duplicate, and Versions

Before 2011, Save As… was how you copied an open document. Choose Save As…, provided a new name and format, and the app wrote a separate file and switched you to it. The process was simple, explicit, and manual.

Auto Save and Versions

In 2011, Apple introduced OS X 10.7, bringing Auto Save and Versions as part of a new document architecture. Under this system:

Documents are automatically saved as you work
Versions are created that you can later browse and restore.
Use Revert To to browse prior versions and restore changes.

This fundamentally changed the workflow: instead of using “Save As…” to create copies or backups, macOS automatically maintains a history of changes for you.

Hidden Save As

Old habits die hard. In OS X 10.8, Apple restored Save As… as a hidden option. To see it, hold down the Option key while the File menu is open. It effectively does: Duplicate + Save + Close Original.

Why might it be hidden? Because when you use Save As… and then use Revert To, you can only see versions from the new document, not the original. This can be confusing.

The Modern Workflow

On current macOS releases, the main document commands are:

Save^[1] — happens automatic saving as you work
Duplicate — create a new document copy in a new window
Revert To — browse and restore previous versions of a document

The Auto Save + Versions system replaces the classic Save As… workflow. The OS now manages saving and versioning automatically, while still allowing you to access the old manual workflow when desired.

When you create a new document, use Save to name it, but you don’t need to make this decision right away. If you quit without saving, the untitled document (with its changes) is still restored next time you open the app^[2]. ↩︎
To complicate things, there are different ways to adopt Auto Save + Versions. Some apps will prompt you to save these untitled documents when you quit, while others (all my apps) will just restore them automatically next time you open the app. ↩︎

Bike: macOS 26

2025-09-16T00:00:00Z

Bike Outliner (1.x) runs well on macOS 26 (Tahoe).

Download

Bike Outliner 2.0 (Preview) also runs well on macOS 26, but I need to adopt the new Liquid Glass UI, and I haven’t decided how I will do that.

I’m looking for ideas.

Here’s what Bike 2 looks like today:

Note: I almost never run Bike with all UI showing like this!

Here’s what Apple’s Notes looks like on macOS 26:

For my taste, this standard macOS 26 Liquid Glass treatment muddies the boundary between UI and content way too much.

Here’s how ChatGPT imagines Bike 2 on macOS 26:

I kinda like it.

Or at least I like idea of drawing boundary around content, and leaving the exterior UI flat against the window. The content is clearly separate from the sidebar and inspector. It’s not really Liquid Glass, but I think it could fit in.

I’m still brainstorming and looking for ideas.

Let me know what you think!

Feedback on my ramblings
Links to apps that you think adopt glass UI well
Mockups of how you think Bike 2 could look on macOS 26

Type, type, type...

2024-11-23T00:00:00Z

Yikes, it was brought to my attention that I haven’t posted here in over a year :/

What am I up to?

I’m still here! Working away on Bike, and keeping TaskPaper well polished. The support forums are still active if you’ve got questions. I just haven’t been posting here.

Why?

For the last year, I’ve been mostly working on Bike 2. It’s a big project, and there’s just not much to show until it’s done. It will get done eventually, but it’s not done yet.

Bike 2 is pretty much all new code. Expected features include stylesheets, outline filtering, and a foundation for many great new features to come. I’m excited about it, but it’s a lot of work.

Type, type, type…

Bike: Outline Paths

2023-11-07T00:00:00Z

Use outline paths to query your Bike outlines. Today they are used through AppleScript and Shortcuts actions. In the future they will be used to build new features such as stylesheets and outline filtering.

Watch the Movie

First, it’s not neccessary to understand outline paths to use Bike. They are a foundation technology–can be complex, and are definitaly a bit geeky.

Outline paths are for users who like to tinker, write scripts, and create themes. I encorage everyone to watch the movie to see what they do, but you are safe to forget the details once you’ve finished.

Learn more in Bike’s User Guide

Bike: Focus Heading

2023-09-07T00:00:00Z

Bike’s new “Focus Heading” feature enables fast keyboard navigation.

Download

Release notes

Watch the Movie

Choice Palette

Focus Heading uses Bike’s new choice palette. This same UI is also used in the new “Format > Add Link to Row” command. I expect I’ll find other uses for it in Bike soon.

If you are a developer and wondering how it’s so fast… it wasn’t me. I’m using nucleo_matcher for the heavy lifting. It’s extremely fast and has a nice API. I recommend checking it out.

Bike: Row Types

2023-08-07T00:00:00Z

Bike Outliner adds row types!

Use row types to add another level of structure and meaning to your outlines. You can now include heading rows, task list rows, ordered list rows, and more.

Watch the Movie

Using Row Types

The easiest way to use row types is through Bike’s new “smart row types” feature. In a new row, type one of the following markdown inspired shortcuts–followed by a space:


`#`	Heading
`>`	Blockquote
```	Code Block
`:`	Note
`---`	Horizontal Rule
`[]`, `-[]`	Task List
`[x]`, `-[x]`	Task List (completed)
`1.`	Ordered List
`-`, `*`, `+`	Unordered List

The shortcut text is replaced and the row type is set. Row types are supported in both .bike and .opml outlines. Learn more about row types in Bike’s user guide.

Bike: Navigation

2023-06-12T00:00:00Z

Bike Outliner adds inline navigation buttons so you can zoom through your outline with just your mouse. It also adds a navigation bar with back and forward history and breadcrumbs.

Watch the Movie

New inline navigation buttons are added after rows with children. Use them to zoom through your outline with just your mouse. They are a nice visual indicator of where you are and where you can go.

Bike’s new navigation bar makes it easy to go back and forward through your history. It also shows you a breadcrumb trail of where you are in your outline. Click a breadcrumb to navigate from that item.

The navigation bar is optional. Personally I find it useful it large outlines, but disable it in smaller outlines.

License Renewal

It’s been a little over a year since Bike 1.0. If you purchased your license more than a year ago you will be prompted to renew your license by this release. I hope you do! I think Bike’s made great progress this year, and I plan to carry that work forward with your support.

Notes:

You don’t have to renew your license to keep using older versions of Bike. Your license unlocks those forever.
Renewal is 50% off the full price and will allow you to unlock an additional year of Bike updates.
There is no penalty for renewing late. You can renew at any time and get a full year of updates from the date of renewal.

Hookmark: Bike Companion

2023-05-09T00:00:00Z

This month Bike is partnering with Hookmark.

Hookmark is a macOS app for creating links to items: files, todos, mails, and more. These links are deep and bidirectional. The latest Hookmark release is updated to work great with Bike.

Bike and Hookmark are companions. Use Bike to store and organize links that you’ve created with Hookmark. Use Hookmark to create deep links into specific rows of your Bike outlines.

Using Hookmark with Bike

Hookmark 30% Off Coupon

Hookmark has as free trial, you can download it out now.

Use the coupon code “Bike-Outliner” to get 30% off Hookmark’s regular price. This coupon expires May 17th.

Bike: Automate with Shortcuts

2023-04-18T00:00:00Z

Bike Outliner adds Shortcut actions! With Apple’s new Shortcuts^[1] app you drag and drop actions to create automated workflows. It’s similar in capability to AppleScript, but much easier to get started.

Download

Bike Shortcut Actions

Bike provides a complete suite of shortcut actions. You can create, edit, move, and delete rows. You can also search for rows and expand or collapse the outline.

Here’s what a shortcut looks like. This shortcut saves Safari’s current tab to a “Links” section in your outline. I’ll walk you through part of this shortcut’s creation in the following tutorial.

Download Shortcut

Bike Shortcuts Tutorial

In this short tutorial I’ll show you how to create a link and throw in a few tips along the way. I’m still learning this new automation technology. If you have any suggestions, please let me know in the comments.

Bike Shortcuts Examples

Cleanup – Collapse all rows except for the selected row where you are currently working.
Save Tabs – Saves all tabs in the current Safari window into the current Bike outline.
Show Matches – Asks for a search term, and then expands outline to show all rows that contain that search term.
Today – Creates a year, month, day outline hierarchy (if needed) for todays date and moves your text caret there so you can start typing.

Shortcuts requires macOS 13 or later and Bike 1.11 or later. ↩︎

Bike: Printing + Quicklook + thumbnails

2023-03-28T00:00:00Z

Bike Outliner now supports printing! It also adds quicklook previews and icon thumbnails for your .bike files in the Finder.

Download

Release notes

Screenshot

Printing

Bike prints the view that you see. Focus into a row and collapse rows to print a smaller part of your outline. Focus out and expand everything to print the whole outline.

Quicklook

Use Quicklook to see the contents of your .bike outline without having to open it. To use Quicklook select file in the Finder and press the spacebar.

Thumbnails

Now when you save Bike will generate a custom thumbnail icon. The thumbnails shows the first page of your outline and adds a “BIKE” label. This makes Bike files a lot easier to spot in the Finder.

Bike: Distraction-Free Outlining

2023-03-13T00:00:00Z

Bike Outliner now supports full screen mode, typewriter mode, and focus mode. You’ve seen these features before, but not combined with Bike’s speed and fluidiy. Try it out, Bike is different.

Download

Release notes

Watch the Movie

Full Screen Mode

Bike now works great in full screen. Text wraps to a specific width and then scales to comfortably fit your window.

Typewriter Mode

Typewriter mode keeps your text centered on screen while you type. Keep your writing where it’s easy to see.

Focus Mode

Your own text can be distracting. Dim it out with focus mode to concentrate on just the sentence you are writing.

Bike: Word Count & Status Bar

2023-03-12T00:00:00Z

Bike Outliner now includes word count and a handy status bar. It’s minimal and can be turned off. Use Bike’s new status bar for quick access to some options, navigation status, and text statistics.

Download

Release notes

Watch the Movie

Bike: Improved macOS Text Checking

2022-12-19T00:00:00Z

Bike Outliner now supports autocorrect, substitutions, user replacements, and improved spell checking! Bike’s text checking interface is custom built, adopting and then improving upon macOS standard behavior.

Download

Release notes

Show and correct errors

Showing and correcting spelling errors is surprisingly problematic in most macOS apps. Bike makes this task straight forward.

Incorrect words show immediately
Correction popups show consistently

Predictable and reversible autocorrect

Autocorrect is a challenging feature. While useful, it will always be wrong or unwanted some of the time. How to design a useful feature that will sometimes be wrong?

The standard macOS approach is to limit the unwanted cases at the cost of making the system more complex and unpredictable. In my mind this isn’t a good tradeoff. Autocorrect is still wrong sometimes, but now you also have a system that’s hard to predict and understand.

Bike’s approach is different. It expects autocorrection to be wrong sometimes and optimizes the system make corrections predictable, visible, and easy to undo.

Autocorrect only depends on caret position and text
Autocorrect doesn’t show completions as you type
Autocorrect is disabled in code formatted text
Autocorrect’s blue underline shows for current sentence
Undo removes only the autocorrection, never your typing
Use Delete key to quickly undo the previous autocorrection

Expanded keyboard friendly checking panel

Standard macOS apps have three text checking UI’s: checking window, substitutions window, and menu items. These are extra windows that you’ll have to manage, and they don’t work well with keyboard shortcuts.

Bike’s approach is different. There’s a single keyboard friendly checking UI with all settings. There are no extra windows to manage, the panel slides into the bottom of your outline window. Use the Escape key at anytime to close the panel and go back to outlining.

Single panel with all features and settings
Panel slides in below outline, no separate window to manage
Text checking is keyboard friendly. Use the up/down arrow keys to correct. Use Enter to accept correction and find next problem. Use Escape to close the panel and get back to outlining.

Mac Text Editing: mark, kill, yank

2022-11-20T00:00:00Z

I’ve been implementing the mark, kill, and yank actions for Bike Outliner. These actions are obscure and under documented. This post documents what I’ve found and includes code I used to implement them.

My understanding is that these features were originally implemented in terminal based editors. Later used by NeXTSTEP. Now many years later they are still with us on macOS.

There isn’t much documentation of the macOS implementation. Much of the following behavior was discovered by experimenting with TextEdit. Probably I’ve missed some things and got some things wrong.

Corrections welcome!

Mark

Marks are from terminal editors where it wasn’t possible to visually select a range of text. When you needed to define a range you would “mark” one end and use the insertion point for the other.

Actions to manipulate the mark:

setMark: Save the selection to the mark.
deleteToMark: Union the mark and selection and delete that union.
selectToMark: Union the mark and selection and select that union.
swapWithMark: Swap the selection with the mark.

Note that on macOS the mark is a range, not a single point. The mark shouldn’t be updated to account for text changes in the editor. When reading the the mark always clamp it to the editor’s text length.

I don’t think there are standard keybindings for mark actions. I think they are mostly used when building up more complex multi-action keybindings. See the keybinding links below.

Kill

When text is deleted by certain actions it gets added to the kill ring. By default the kill ring contains a single text entry. If you change the NSTextKillRingSize system default the kill ring can contain multiple entries.

Actions that kill text:

delete:
deleteToMark:
deleteToBeginningOfLine:
deleteToEndOfLine:
deleteToBeginningOfParagraph:
deleteToEndOfParagraph:

Generally killed text it is added to the ring as a new entry. Once the ring is filled it will wrap and new kills replace older kills.

The exception is when you repeat the same kill action. In that case the killed text is combined with the current kill entry. This coalescing stops when you edit text or change the selection.

To quickly try out kill use:

Control-k: To kill using deleteToEndOfParagraph:.

Yank

Text can be retrieved from the kill ring by yank:

yank: Replace the selection with the most recent kill text.
yankAndSelect: Replace the selection with the most recent kill text and select the inserted text. Repeat calls to yankAndSelect: will cycle through the kill ring. Cycling pauses when you make an edit.

Each app maintains a private kill ring. You can kill text in one view and then yank it into another view within the same app. You can’t kill or yank between apps.

To quickly try out yank use:

Control-y: To yank text from the kill ring using yank:.
To yankAndSelect: you will need to add your own binding.

Why would you use these actions?

I have seen these actions used most often in custom multi-action keybindings. Marks are useful for saving and restoring the selection. Kill and yank are useful for moving text without overwriting the pasteboard.

To learn more about keybindings:

How to implement in your own text editor?

I’ve created KillRing.swift class to get you started.

The kill ring needs to maintain some state. Your editor should call selectionChanged() and textChanged() anytime they change in your editor. When killing and yanking your editor should perform all related changes within the callback block.

Bike: Innovative Rich Text Editing

2022-10-11T00:00:00Z

Bike Outliner now supports rich text!

Download

Release notes

Bike’s rich text editing should be familiar. There’s also innovation^[1]. I’m trying to improve the fundamentals of how rich text editing works.

Watch Bike’s Rich Text Movie

Inspired by Markdown

Bike’s rich text editing is inspired by Markdown.

I like Markdown because the formatting is directly accessible. The formatting characters are always right there to guide my edits.

I dislike Markdown for the same reason. Those formatting characters are always visible. They make my text look messy.

I want clean looking outlines, so Bike uses rich text. I would also like my outlines easy to edit. That’s where I think rich text has problems and Bike’s typing affinity is a good solution.

Editing Puzzles

Rich text is difficult when you need to insert text at formatting boundaries. Markdown has formatting characters to guide you. In rich text there are no such characters, and so you must rely on these conventions:

Use formatting from text before the caret
At start of line use formatting from text after caret
Some formatting (links for one) might use different rules

If you need to perform an edit that doesn’t fit into these conventions then rich text editing becomes painful.

Puzzle 1:

Start with “Hello” in bold. Then add " world" in normal text. In Markdown this is easy, just place " world" outside the **s:

From: **Hello**
  To: **Hello** world.

Now try the same thing in a rich text editor.

Not as easy. You need to exit from bold typing mode. Probably you will do Command-B to do that. How you exit depends on the previous formatting–in this case it’s Command-B, but if the formatting was different then you would need a different command. There’s no consistent way to end formatting, and go back to typing unformatted text.

Puzzle 2:

Insert "cool " at the start of a link. In Markdown it is straight-forward. You have the syntax characters to guide you, insert inside the braces:

Start: [links][...]
  End: [cool links][...]

Now try the same thing in a rich text editor.

Painful. You are editing against the conventions, "cool " doesn’t want to be part of the link. Best approach I’ve found is to select the first letter in the link “l” and then type to replace it to catch the formatting. We shouldn’t have to do these editing gymnastics.

Bike’s Solution: Typing Affinity

Bike’s typing affinity solves both editing puzzles easily. At each formatting boundary (including start and end of line) Bike’s text caret shows a tail. Use the arrow keys to point the tail at the formatting you want. Thats it.

Bike’s approach is just as precise as Markdown and requires fewer keystrokes. It does this without littering formatting characters throughout your document.

Give typing affinity a try. Perform the above editing puzzles in Bike and see how clean and predictable rich text editing can be.

Some of this innovation is rediscovered ↩︎

Changelog Interview

2022-06-10T00:00:00Z

I just did an interview for The Changelog:

Combine's .collect(.byTime)

2022-05-23T00:00:00Z

Post mostly for programmers…

The biggest bug in Bike’s 1.0 release was excessive CPU use while in background. This bug is fixed now, but embarrassing since Bike is a macOS native app that isn’t supposed to do that sort of thing.

How did it happen?

First, I didn’t realize that each time you use .collect(.byTime) you are setting up a new repeating timer. I had expected a timer was involved, but thought it would only get scheduled when new items were coming into the publisher. Nope, it’s repeating once the pipeline is setup.

Second, I stress test Bike with one big outline, but this problem didn’t show up noticeably until you opened multiple documents. I was using .collect(.byTime) a few times per document. After the issue was reported I tried opening 30 documents and the CPU would sit at 50% usage when in the background. Ugh.

Why use .collect(.byTime) in the first place? Collect by time is really useful because it allows your model to change often, while not flooding your view with updates.

For example Bike schedules background spell checking when an item scrolls into view. When that work is finished the view needs to be updated. The problem is spell check results can arrive quickly and a separate view update for each new result will slow down scrolling.

Bike used .collect(.byTime) to collect those spelling results, but only update the view every 16ms or so. It’s a big performance win and makes scrolling fast while also showing spelling errors “immediately” as they scroll into view. Except for the background CPU usage it’s great.

I’ve posted a .collect(.byTime) replacement (for my use case) here. It solves the problem by only scheduling on the runloop once per group of incoming results. It appears to be working well and Bike now uses 0% CPU when in background even with 30 documents open.

Bike: Tool for thought

2022-05-17T00:00:00Z

I have a new app!

Bike is a fast and fluid outliner app for macOS. Your thoughts and ideas flow smoothly across the screen. Bike also works well with big files, uses open file formats, and is scriptable.

Try Bike, it feels different:

Why Bike Outliner?

We were promised bicycles for the mind, but we got aircraft carriers instead – Jonathan Edwards

That’s why I’m building Bike. I think macOS needs more “bicycles for the mind”.

Bike is small enough to fully understand. Once understood it’s flexible enough to be used for many purposes.

Bike is small, but designed for real work. It’s fast. It can handle big projects that break other outliners. Bike’s also fast at the basics–opening files, scrolling views, and resizing windows. Bike won’t slow your Mac down.

Bike makes your work open and accessible. Outlines are stored in text files using standard file formats. Bike is also scriptable. Automate and extend Bike into your own workflows with scripts.

Bike is just getting started. I’ve been building on the outliner idea for a long time, Bike is the next chapter. I hope you’ll give it a try, get a license, and let me know what to improve for the next release.

Moby Dick Workout

2022-04-12T00:00:00Z

How many items should your todo list handle? Not the most pressing question in the world, but one that I sometimes wonder about.

I think productivity apps should scale to “user generated” content. I don’t expect every app to load multi-gigabyte log files, but it should handle what I can write myself.

I use “Moby Dick” to test that. I know it’s longer and uses bigger words than anything I’ll write. If the app works well with “Moby Dick” then that’s a good indication that it will handle my needs also.

Here’s the test:

Open “Moby Dick”. Fast?
Scroll to end. Resize the window. Fast?
Scroll to middle. Resize the window. Fast?
Select all. Cut, Paste, Undo. Redo. App still standing?
Edit some content near the middle. No typing lag? No scroll jumping?
Repeat 2-5 until you get bored, then open macOS Activity Monitor and see if it’s using acceptable amount of Memory.

Computers are really fast, Moby Dick is tiny compared to this fastness. If an app doesn’t pass this test that suggests to me that there might be problems. This is just a test–a good app for you might fail this test, a bad app for you might pass.

Test Files:

MobyDick.bike
- This is what I use to test my app Bike Outliner
MobyDick.opml
- This is OPML file useful for testing outliner apps
MobyDick.markdown
- This is a Markdown file useful for testing markdown apps