Stuart Regan

Thomas Paul Mann

We did our first Launch Week where we released something new every day. Read this blog post to get an overview of what we announced during this time. Spoiler: It's a lot!

## Day 1 - Monday 18 July

### 📚 Community Stories
Launch Week started with stories from community members who shared their favorite features about Raycast and gave an insight into how they use Raycast to make their day-to-day work smarter.

<Media src="/uploads/launch-week/community-stories-1.png" />

We had the opportunity to speak with a range of folks, from Product Designers and Engineers to Product Managers, across the globe, working at companies such as GitHub, Vercel, and Linear.

<Media src="/uploads/launch-week/community-stories-2.png" />

And since then, we’ve added eight more the following week for other community members that submitted their stories.

## Day 2- Tuesday 19 July

### 💫 App Icon

Our long-overdue app icon received some much-anticipated attention, falling in line with Big Sur’s updated icon shape. We dropped [a hint](https://twitter.com/raycastapp/status/1549363427302207488) before launching our new face of the app, showcasing the many requests we’ve had over the last couple of years, and giving you an insight into what was to come.

<Media src="/uploads/launch-week/app-icon.png" />

Over the last couple of years, we’ve explored multiple options and directions before settling on the metaphor of a keycap. We took the literal, tangible thing every user (should) use when opening Raycast and what they use to navigate through Raycast and put our spin on it.

The red glow brings in the element of the Raycast branding, with the (say it in Jony Ive’s accent) aluminum texture you come to expect from Apple products.

### 🖌️ App Experience

Along with the updated app icon, we also worked on a refresh to the app, including a much more consolidated design, with multiple community requests over the years.

<Media src="/uploads/launch-week/searchbar.png" />

We started with increasing the size and height of the navigation bar. For some time, the feedback we’ve received is the navigation (search) bar is too small and feels lost amongst the results and other components. So we increased the height and text size and refined some other small accessories that sit within the navigation bar too.

And to balance out the new app, we wanted to bring more prominence to the command and application icons in a list view, increasing the size by 25%, from 16 to 20 pixels. While it might look like we’ve made a bigger change here, the subtle adjustment helps you identify commands and apps a lot quicker, speeding up the review time to read the title, and other text, before hitting enter.

<Media src="/uploads/launch-week/action-bar.png" />

What might feel like the most significant change is our new Action Bar. What once used to be a small, floating button hiding the infamous action panel (`⌘` `K`) is now a wholly redesigned component containing the primary and secondary actions, the previous floating tab, and toasts for user feedback during running actions.

The new and improved design brought three components into one. It opened up even more space than we had before to introduce more contextual and helpful information that once never existed and often constrained the overall experience for new and experienced users.

<Media src="/uploads/launch-week/action-panel.png" />

And we couldn’t introduce the Action Bar without giving the Action Panel a minor refresh too. We brought over a consistent list item component from what you see in the main app window. We updated the list view inside the Action Panel, making the new panel design feel more spacious and clear when looking for that all-important action.

### 🤏 Compact Mode

Something many have asked for, but probably many did not expect, was the introduction of Compact Mode – a way to open Raycast minimally – hiding the root list and suggestions.

<Media src="/uploads/launch-week/compact-mode.png" />

We added a new look when opening the Raycast app with the much more simplistic approach of only showing the navigation bar to search and the action bar for showing any top-of-the-list items and primary actions. Configurable from within Preferences, the Compact Mode is now a staple of Raycast.

<Banner>Fun fact: The app icon and refreshed app design came from a design week in London, where we flew out Nichlas from Norway to link up with Petr, Thomas, and Stuart, to spend a week designing a new app icon, and community swag. The updated UI and Compact Mode came out of an idea we had after coming back from a team meal.</Banner>

### 🎨 Icon Set

We teamed up with James McDonald to bring a new and consistent icon set to our design system, also available in our API.

Before, our icon set combined icons from packs and custom variations to fit our needs. Now, after a collective effort between James and our designers, we redesigned our icon set and introduced over 400 icons to developers and designers.

<Media src="/uploads/launch-week/icon-set.png" />

The new icon set allowed us to create a level of consistency that we didn’t have before and unblocked us from creating new icons at speed in the future. Now, with rules and guidelines, set stroke widths, and an agreement on radii, designing a new icon when we need one will be more accessible than ever.

## Day 3 - Wednesday 20 July

### 👥 Raycast for Teams

At the midway stage of Launch Week, we officially launched Raycast for Teams out of beta, allowing companies to start using Raycast in their teams. Our launch started on Product Hunt, where we reached the 4th Product of the Day with 500 upvotes!

<Media src="/uploads/launch-week/teams.png" />

Teams can develop their extension to reimagine completing tasks and improving their daily workflows, sharing extensions with their team members. With shareable Quicklinks, they can stay on top of the latest documents and common links. Shareable Snippets speed up canned responses for things like support messages, or keep formats consistent in documentation.

<Media src="/uploads/launch-week/product-hunt.png" />

Want to learn more about Teams? Check it out [here](https://www.raycast.com/teams).

## Day 4 - Thursday 21 July

### 🍫 Menu Bar Commands (Beta)

A while ago, we launched the Menu Bar option for My Schedule, and it received an overwhelming response.

Using the incredibly positive feedback, we saw an opportunity to extend your productivity in a new way – through the menu bar. And so, on Day Four, we launched Menu Bar Commands. A new way to stay on top of day-to-day information.

<Media src="/uploads/launch-week/menu-bar.png" />

Developers can build extensions with menu bar commands and publish them to the Store so that you can see glance-able information at the top of your screen. We've already seen a great response in developers adopting new ways to make you productive. From Linear notifications to GitHub pull requests and even the latest track playing on Spotify.

### 🤬 Arguments for Commands

The long-awaited demand for arguments from Script Commands also went live on Thursday, now available in a command. So you can now create a Command and include up to three queries to search for information on your common websites or create an issue simply in Linear.

<Media src="/uploads/launch-week/arguments.png" />

### ⚙️ API Updates

And to wrap up Day Four and the new additions to the API, we dropped a few more updates:

We ported Background Refresh from [Script Commands](https://github.com/raycast/script-commands) to Extensions to keep Menu Bar Commands up-to-date. Background Refresh is configured with a new interval option in the Extension's manifest and works for "no-view" mode commands

We've released new React hooks to make it faster to build extensions that follow best practices. To do this, we looked at the Extension's repository for use cases and how we can improve them. Most Extensions connect to APIs: they make network requests, show a toast to handle errors, and add caching and optimistic updates to speed up interactions. Utils are available via a new [public npm package](https://www.npmjs.com/package/@raycast/utils).

In our progress to move our native Extensions over to the Store and open source them, we began migrating Linear, re-writing the entire Extension in TypeScript. We're proud that the API can power such complex extensions, and the [Linear extension](https://www.raycast.com/raycast/linear) is now available for your contribution. We've also open sourced the [Google Workspace](https://www.raycast.com/raycast/google-workspace), [Zoom](https://www.raycast.com/raycast/zoom) and [Asana](https://www.raycast.com/raycast/asana) extensions after Launch Week.

## Day 5 - Friday 22 July

### 👕 Community Swag

And finally, to end the week in style, we announced something to give back to the community for all the efforts and contributions: SWAG!

<Media src="/uploads/launch-week/deepu.png" />

Except for Deepu, this may have come as a surprise to many (like a lot of Launch Week announcements), but we made sure to do it in total Raycast fashion – inside the app 😉

<Media src="/uploads/launch-week/swag.png" />

We hand-picked community members whom we felt made an impact on the community from their contributions to the Store, developing extensions, and providing support to others.

We wanted to ensure that the work and efforts of members in our community were rewarded and recognized, and to show our gratitude to people who are helping others and helping to make Raycast the product it is, that you know and love.

And that was our first Launch Week. We hope you enjoyed it as much as we did.

An overview of what we shipped during our first Launch Week.

Launch Week Summary

From day one, we knew that Raycast would only work if developers could extend the app. So in October 2021, we released the [beta of our Extensions API and Store](https://www.raycast.com/changelog/1-25-0), where developers can build and publish extensions for everyone. 

Since then, 300 developers have contributed over 500 extensions that people have installed over half a million times! These numbers humble us 😌 And today, we're still making it easier for developers to extend Raycast, so it's even more powerful for everyone. 

## Breaking out of Raycast with Menu Bar Commands

For a long time, Commands could only live in the Raycast window. From today, Commands can put glanceable information in the Menu Bar 💪 

<Media src="/uploads/api/menu-bar-command.png" caption="Unread Linear notifications in the menu bar" />

When we put the option to show [upcoming events in the Menu Bar](https://www.raycast.com/changelog/1-32-0) to the My Schedule Command, your responses were so overwhelming that we couldn't keep this feature to ourselves. New APIs allow putting a title, icon, and menu in the Menu Bar. It builds on top of our excellent developer experience with React and TypeScript.

Here's a simple Command that shows unread GitHub notifications in the menu bar:

```jsx
import { getPreferenceValues, MenuBarExtra } from "@raycast/api";

export default function MenuBarCommand() {
 const { data, isLoading } = useNotifications();

 return (
 <MenuBarExtra icon="github.svg" isLoading={isLoading}>
 {data?.map((notification) => (
 <MenuBarExtra.Item 
 key={notification.id} 
 title={notification.subject.title} 
 />
 ))}
 </MenuBarExtra>
 );
}
```

To keep Menu Bar Commands up-to-date, we ported Background Refresh from [Script Commands](https://github.com/raycast/script-commands) to Extensions. Background Refresh is configured with a new interval option in the Extension's `package.json`. 

After you configure a Command, Raycast takes care of the rest. We repeatedly execute the Command in the background by using the system to determine the most efficient time. We also show when a Command was last refreshed. New Commands can't run in the background automatically; a user needs to activate them after a fresh installation from the Store.

Menu Bar Commands are great for showing frequently pulled information, like open GitHub issues, unread Linear notifications, or your current Slack status. Both features are in beta, and we're excited to see what you'll build with them. Follow [this guide](https://developers.raycast.com/api-reference/user-interface/menu-bar-extra) for your first Menu Bar Command.

## Make simple things simple and complex things possible

We designed Raycast's user interface to be as intuitive as possible. Once you learn the basics, you can apply them to everything. The main goal for our API is to make it easy for developers to build on top of this foundation. By using our built-in components, developers can concentrate on their business logic.

We've released new React hooks to make it faster to build extensions that follow best practices. To do this, we looked at the Extension's repository for use cases and how we can improve them. Most Extensions connect to APIs: they make network requests, show a toast to handle errors, and add caching and optimistic updates to speed up interactions.

Drum roll, please…🥁 you can now get all this free with a single hook: `useFetch`. Here's an example:

```ts
import { getPreferenceValues } from "@raycast/api";
import { useFetch } from "@raycast/utils";

export type Notification = {
 id: string;
 subject: {
 title: string;
 };
};

export function useNotifications() {
 return useFetch<Notification[]>("https://api.github.com/notifications", {
 headers: { 
 Accept: "application/vnd.github+json",
 Authorization: `token ${getPreferenceValues().token}` 
 },
 });
}
```

In our example, we halved the lines of code needed to search npm packages with the `useFetch` hook. The hook builds on top of other custom hooks. This structure makes it flexible to integrate with your needs, for example, using [Octokit](https://www.npmjs.com/package/octokit) to connect to the GitHub API. Run `npm install @raycast/utils` to use the new hooks in your project.

We're excited to see how you use the hooks! We hope they'll push the boundaries while keeping our Extensions platform consistent. We're also planning to make other common use cases more straightforward, so stay tuned for updates. 

## Open-sourcing the Linear extension

Another mention is that we converted the native Linear extension to TypeScript and now [open source it](https://github.com/raycast/extensions/tree/main/extensions/linear). We're proud that the API can power such complex extensions. 

<Media src="/uploads/api/linear.png" caption="New and open source Linear extension" />

We collaborated with [Thomas Lombart](https://twitter.com/thomas_lombart), the developer of the [Todoist Extension](https://www.raycast.com/thomaslombart/todoist), to convert the Linear extension. Here's what he had to say about our API:

"*Working with Raycast's API is delightful in every way. You can clearly see it's something made by developers. No matter what you use from the API, it's always thought through, reliable, intuitive and documented extensively. After months of working with the API on various Raycast extensions, I'm confident it's possible to build one with a great UX in less than a day."*

By converting the Extension, we also added a Menu Bar Command to show unread notifications, a new Command that uses arguments to create issues for yourself quickly, and improved more things.

After Launch Week, we've also open-sourced the [Google Workspace](https://www.raycast.com/raycast/google-workspace), [Zoom](https://www.raycast.com/raycast/zoom) and [Asana](https://www.raycast.com/raycast/asana) extensions and we are working on more of them. This is one of the ways of giving back to our community. Plus, it's a great showcase of all the features the API offers.

## And one more thing while you're here…

We also ported more functionality from Script Commands. Extensions can now define arguments, which enable simple forms that live in the root search of Raycast. 

Developers can modify the subtitle of a Command dynamically. Combined with Background Refresh, this is another way to present information to the user as dashboard-like items in the root search.

That's probably enough updates, for now 😅 Safe to say, we're constantly blown away by what you build. We can't wait to see what you'll create next with these additions to our developer platform. See you in the pull request reviews 😉

How we're making it even easier for developers to extend Raycast

Making our API more powerful

Our [community](https://raycast.com/community) made Raycast the one-stop solution to enhancing productivity on a Mac, with more than [500 extensions](https://github.com/raycast/extensions) and [600 scripts](https://github.com/raycast/script-commands). Starting today, we’re excited to bring this experience to companies with *Raycast for Teams*.

During the beta phase of development, we learned how engineering teams at Atlassian, GitHub, Shopify, and other organizations use Raycast for Teams with a shared mindset of making things more efficient. We want to bring this mindset to every organization, helping teams like yours build internal productivity tools tailored to your needs.

[Our pricing](https://raycast.com/pricing) stays simple: Raycast is free for individuals and paid for by teams (although our Basic Team Plan lets you explore these new features for free). 

## Shared Commands, Quicklinks, and Snippets

Teams can now speed up their internal workflows with Shared Commands, Quicklinks, and Snippets, bringing us one step closer to making work frictionless.

### 1. Shared Commands

Sooner or later, every engineering team relies on a bunch of shell scripts to handle internal operations. Scripts can become time-consuming, difficult to maintain, and often aren’t accessible to everyone who needs them.

<Media src="/uploads/teams/private-store.png" caption="Build internal productivity tools and share it in a private Store" />

With Raycast, your team can use our API to build custom tooling that lets you do your best work at speed. Build lists, grids, and forms that connect to your tools, or anything from admin panels to waiting list automation - all with a few keystrokes.

You can share all Commands in a Private Extension Store for the team to install. Speeding up the team’s workflows means you have more time to spend on the stuff that matters most.

<Banner>Build a brand guideline to make your colors, icons, and assets accessible to every team member. Connect to your backend to search your customer base. Or build commands to manage refunds, waiting lists, and other operational tasks.</Banner>

### 2. Shared Quicklinks

As teams grow, we naturally rely on more tools, apps, and documentation. What starts with a few links can end up with a mess of bookmarks that every person maintains, to varying degrees of success. 

<Media src="/uploads/teams/shared-quicklinks.png" caption="Navigate links faster with Shared Quicklinks" />

With Raycast, you can convert long links into simple bookmarks for the whole team to access. [Shared Quicklinks](https://manual.raycast.com/quicklinks) let your teammates quickly find roadmaps, repositories, or even that favorite Friday playlist. And they work with desktop apps like Linear, Notion, and Slack. So you and the team have everything you need to access quickly, at your fingertips.

<Banner>Add Quicklinks to your repositories, product roadmaps, and project management boards. Create more Quicklinks as you go to help onboard new joiners faster.</Banner>

### 3. Shared Snippets

Keeping messaging consistent becomes a bigger challenge the bigger your team gets. [Shared Snippets](https://manual.raycast.com/snippets) help your team save time and hassle by storing and inserting the text you use most daily.

<Media src="/uploads/teams/shared-snippets.png" caption="Speed up typing with Shared Snippets" />

Create canned responses to help with support, easily give code reviews in a set format, and embed consistency across documentation. Shared Snippets get updated automatically when someone makes a change, so everyone’s always on the same page. They aren’t limited to your browser and work regardless of what app you use.

<Banner>Add company details that every employee needs, templates to your hiring inbox so you can respond more quickly to candidates or use dynamic placeholders to communicate with a consistent tone of voice.</Banner>

## Easy to start, powerful to scale

Raycast for Teams is for everyone. Every member of your team can create a Command, Quicklink, or Snippet and share it with the company. Quicklinks and Snippets are an easy way to get a productivity boost without ever needing to write a line of code. And to unlock the full power of Raycast, developers can use our API to build Commands.

Our API is built on top of Node, React, and TypeScript. A great developer experience lets engineers connect to APIs, access databases, or execute shell scripts in no time. This setup gives every engineering team a toolkit to build their productivity tools and share them in a Private Store. And the best part - new joiners get all the productivity boosts from day one.[](https://raycast.com/pricing)

To get started with Raycast for Teams, create an organization in the macOS app and share the invite.

The brand new way to build internal productivity tools tailored to your needs. 

Bringing Raycast to Teams

We can't believe it's been almost two years since [we announced Raycast to the world](https://www.raycast.com/changelog/0-22-6). And while the design of the macOS app has mostly stayed the same, many things around it have changed. 

We introduced our Extensions API and Private Extensions Store, for example. Our [Slack Community](https://raycast.com/community) grew to more than 6,000 members. And tens of thousands of users have taken to using Raycast to make their everyday work smarter. 

Today we're announcing a fresh look and feel to address the feedback and demand from our growing community. 

Here at Raycast, we have three design principles: fast, simple, and delightful. We hope you can notice them in every corner of our products, from big features to tiny details. The changes we've made aim to make the app even easier and faster to use going forwards while maintaining its beauty through simplicity.

Here's what we've done and why 👇

## 1. A bigger search bar and icons

The search bar is at the center of Raycast. Almost every interaction goes through it. We've made the bar bigger to reflect its importance, grab the user's attention and set it apart from the search results below.

<Media src="/uploads/redesign/navbar.png" caption="Bigger search bar" />

We also increased the size of the leading icon of the search results, making it quicker to scan for what you need to find.

## 2. An all-new action bar

Pressing `⌘` `K` in Raycast lets you find and take any action in the app. Magic, right? But despite being one of the essential features, it's been hidden behind a small button and is easy for new users to miss. 

<Media src="/uploads/redesign/actionbar.png" caption="New action bar" />

To fix this problem, we've simplified the user interface and consolidated actions, toasts, and navigation titles in an all-new action bar at the bottom of the window.

<Media src="/uploads/redesign/actionbar-left.png" caption="Action bar with toast" />

The left part of the bar shows the navigation title of the active command and any toast. We moved toasts into the app window and introduced a dedicated shortcut to expand them, making it quicker to show details. 

<Media src="/uploads/redesign/actionbar-right.png" caption="Action bar with open panel" />

The right part of the bar shows actions available in the current context, along with their keyboard shortcut. This lets users learn action shortcuts to make using Raycast even faster.

## 3. Our new icon set

We collaborated with Designer [James McDonald](https://twitter.com/jamesm) to overhaul our icons and create a distinguishable set that could be used across the app. He kept the icons simple with an outline style, and a bolder stroke width to make them more prominent.

<Media src="/uploads/redesign/icons.png" caption="New icon set" />

Here's what James had to say about the collaboration:

> The team at Raycast reached out to me with a clear goal: "We want to revamp our icon set completely," – And that's what we did.
> 
> The icons follow the same rules for stroke width and corner radii. The result of these rules is a balanced set of icons that feel fresh and new, making them timeless for future updates.

## 4. More focus with Compact Mode

With Compact Mode, we've made Raycast's user interface more focused. A typical flow is to open Raycast and type in what you're looking for until you press enter to open the selected search result.

<Media src="/uploads/redesign/compact.png" caption="Compact mode" />

Compact Mode optimizes this flow, blending all other elements for a minimal appearance. The new mode can be enabled in Raycast's preferences to bring more focus to your work.

## 5. A fresh app icon

Since Apple announced Big Sur in November 2020, icons share a standard set of visual attributes, including the rounded-rectangle shape, front-facing perspective, and more. Since then, our round and flat app icon has felt outdated, so a new icon was long overdue. 

But the wait is finally over! Here's our new app icon to fit nicely in your docks.

<Media src="/uploads/redesign/new-appicon.png" caption="New app icon" />

We experimented with metaphors to bring a three-dimensional look to our icon, trying glass cubes, magnifier glasses, and more. But what stuck was a keycap. The keycap represents our focus on the app's keyboard accessibility. Apple's Magic Keyboard inspired the visual look, allowing us to introduce alternative icons.

<Media src="/uploads/redesign/appicons.png" caption="Alternative app icons for internal and debug builds" />

And that's it! We've made five changes to refresh the app's look and feel while keeping its core mechanics in place. Designing an app core to people's daily workflows isn't without its challenges. So as always, we'd love to know what you think about our new pixels.

How we’ve changed our app design to make it even easier and faster to use. 

A fresh look and feel

The concept of Rayday is simple. Every Friday, everyone can use the day to work on something that benefits Raycast. From new features, to fixing bugs, drafting documentation or tidying up, it’s time for us to take a break from project work. As well as getting creative with our own ideas, it’s a great chance to act on feedback from our users and community too.

This isn’t something new in the tech world; companies like Google and Atlassian have similar initiatives, often called ‘hacking’. But it is something important – coming up with innovative ideas is vital to our success. And every team member should be able to contribute to this. With Raydays, we make entrepreneurial thoughts a core part of our culture.

## How Rayday works

In the morning, we start a Slack thread with what everyone wants to hack on. During the day, we don’t schedule any meetings and there’s no obligation to be online. We show what we’ve done in our team meeting the following Monday.

We learned that it’s best to finish projects during one day. Otherwise other things take priority again and it’s harder to get that feeling of accomplishment. If something is too big for one Rayday, we either reduce the scope or break the work into chunks for multiple Raydays.

<Media src="/uploads/rayday-02.png" caption="My Schedule menu bar app, built on a Rayday" />

For example, one of our software engineers Sorin, hacked the initial version of the [My Schedule menu bar app](https://twitter.com/raycastapp/status/1525113720137035776). It showed the upcoming meeting and clicking on it joined the conference call. Our users really enjoyed this, so he added more functionality over the next few Raydays too.

## What we’ve done in Raydays so far

Many of our most used features started unplanned, driven by team members. The beauty of working on something that you use every day is that you get to solve your own problems too.

<Media src="/uploads/rayday-05.png" caption="Snapping of Raycast window, built on a Rayday" />

During the last 6 months, we:

- Addressed user feedback like [always opening Google services in Chrome](https://www.raycast.com/changelog/1-29-0)
- Added new core features like the [App Uninstaller](https://www.raycast.com/changelog/1-31-0)
- Paid attention to little details like an [indicator for running apps](https://www.raycast.com/changelog/1-29-0) or an [overly satisfying way to re-center the Raycast window](https://twitter.com/parkerhendo/status/1511845347349258242)
- Wrote [Twitter threads](https://twitter.com/raycastapp/status/1525113720137035776)
- Built various internal extensions such as an admin panel and a feedback management system
- Shipped silly things like the [confetti cannons](https://www.raycast.com/changelog/1-31-0) or a [lightsaber cursor for May 4th](https://www.raycast.com/changelog/1-34-0)
- And did a ton more ✨

## Hacking has always been a part of our culture

Since the start of Raycast in 2020, we’ve hacked on features on the side of our everyday workload. We added Clipboard History on the flight to the Y Combinator W20 batch. Floating Notes, Script Commands and [ray.so](http://ray.so/) came out of our first hackathon and Window Management and Window Switcher got built on the side too…the list goes on and on.

Formalising this into Rayday every Friday has helped keep the ritual going when things get busy and makes sure that people have dedicated time for work outside of their usual projects.

## Even with Rayday, we still ship other features regularly

Though 20% of our time every week seems like a lot to be working on side projects, Rayday hasn’t affected our pace of releasing other features at Raycast.

That’s because we prioritise focus time with only one entire team meeting each week. The rest of the time we work autonomously, communicate asynchronously and collaborate ad-hoc. This enables everybody to have time for deep work and guarantees that we can still release a [big update every two weeks](https://www.raycast.com/changelog).

<Media src="/uploads/rayday-03.png" caption="Command to fire a confetti cannon, built on a Rayday" />

Rayday also comes with challenges. Sometimes urgent work, such as bug fixes or features for the next release, take priority. In this case, involved team members opt out of Rayday. We rely on the discipline of individuals to plan their work accordingly. As we all know, it's hard to estimate software development. We're mindful about not increasing the workload and keep improving our processes to save space for Rayday.

As we grow the team, we’ll continue to stay creative and hack every Friday! It’s one of the main things people look forward to every week, myself included 😊

How it works, why it matters and what we’ve done so far. 

We hack every Friday

At the end of 2021, we set ourselves a goal to have a simple, transparent, and fair compensation framework for our fully remote company. So at the start of 2022, we began paying location-independent salaries. No matter where you’re based, we pay the same salary for a role – and here’s why.

## The pandemic changed the way we work forever

Of course, the topic of how to compensate remote employees fairly isn’t a new one. But when we started to grow our team in April 2020, it coincided with coronavirus, lockdowns and global uncertainty.

It seemed a natural first step to make our team fully distributed. This allowed us to expand our search from London to Europe, and hire our first employees in Norway, Germany, and Belarus. Back then we took the more traditional or conservative approach and adjusted salaries based on location, using [GitLab’s compensation calculator](https://about.gitlab.com/handbook/total-rewards/compensation/compensation-calculator/) for reference.

But as we grew the team during 2021, we saw that salaries in Europe vary heavily within countries and even cities. It was time-consuming and error-prone to research fair market values. This was frustrating for candidates and us. Plus, it felt at odds with [our values](https://www.raycast.com/careers#our-values) to be transparent and straightforward. So we decided to pay location-independent salaries, using London - which is amongst the highest salaries for tech companies in Europe - as a reference.

## Why location-independent salaries fit our culture better

We aspire to be one of the most attractive workplaces for product-minded people in Europe. To live up to this we need to attract the best people, and compensation is a big factor. We want to be upfront about this with candidates, so [we share our salaries publicly when we’re hiring](https://www.raycast.com/careers).

On top of that, a location-independent compensation framework better fits our company culture because:

1. **We focus on outcomes.** Everything we do at Raycast is optimised to deliver an outstanding product. It doesn’t matter where someone lives or when they work. The outcome of every day, week, or month is what makes a difference. From our perspective, people who do the same work should get the same salary.
2. **We value simplicity.** Hiring a remote workforce is complex. Even with tools like Deel which simplify the process, it’s still tough to align on compensation. Accurate and fair market values are time-consuming to research and often no longer represent in the hiring market.
3. **We’re transparent.** We value transparency internally and externally. In the past, we aligned on compensation in the first interview call. We want to be upfront to set the right expectations. This goes both ways; we get folks excited who may have earned less in their countries but may deter talent from higher salary regions.
4. **We aim to be fair.** Somebody who can negotiate well shouldn’t end up with a higher salary for doing the same job. Instead, performance and work etiquette should define compensation. So we do what we can to deliver a fair compensation model, whilst acknowledging some parts are outside our control, like local taxes.

## We’re operating in a heated job market

The [tech job market](https://blog.pragmaticengineer.com/advice-for-tech-workers-to-navigate-a-heated-job-market/) is very heated right now, and remote working is here to stay after the pandemic. This forces companies to expand their search radius for talent, which in turn impacts local hiring markets. People looking for work have a bigger pool of opportunities to choose from, and local salary expectations get bent. As a fully distributed company with roots in Europe, we want to be ahead of this curve.

## As always, everything has trade-offs

We know this approach doesn’t come without downsides. Competitors might outbid our talent, companies in the Bay Area might pay more than us, and high salaries might impact diversity.

But compensation is only one part of a job and we believe we can offer a lot more than that at Raycast. We work on something that we use every day, hack on new things every Friday and get together on retreats once a year. We haven’t figured everything out yet, but we’re always improving our performance framework, company culture, and everything else that makes Raycast a meaningful place to work.

If this sounds interesting to you, [check out our open positions](https://www.raycast.com/careers#open-positions). They’re all fully remote in the UTC ± 3 hours timezone.


Remote work is here to stay and location-independent salaries are our simple, transparent and fair compensation framework for it.

Why we pay equal salaries, wherever you work

Petr Nikolaev

At **Raycast**, we make work frictionless. In the past year, we built features that made it easier for people to focus on their work. Today, we take the next step in our journey of bringing back joy to digital workspaces.

We're excited to announce that we've raised $15 million in Series A funding led by Accel and Coatue. At the same time, we're making our Extensions API and Store generally available and opening up early access to team features.

Here are the three exciting announcements from us:

1. **Extensions API & Store:** From today on, you can access an ever-growing platform of productivity tools right in Raycast. Our community has already built more than 100 extensions, including Figma file search, home automation and GitLab integration. Our [React and TypeScript API](https://developers.raycast.com) lets you build extensions with familiar tooling and share it with our community via our [Store](https://raycast.com/store).
2. **Team features:** You can sign up for [early access](https://raycastapp.typeform.com/teams) to be amongst the first ones to experience Raycast for teams. Companies rely on an ever-growing jungle of SaaS tools, leaving teams drowning in inefficient workflows. Our team features allow co-workers to build and share productivity tools that suit their setup and save entire departments time.
3. **Series A funding:** We have raised $15 million in Series A funding. Accel doubled down on their Seed investment and lead the Series A together with Coatue. We're also happy to welcome Koen Bok (CEO, Framer), Karri Saarinen (CEO, Linear), David Cramer (CEO, Sentry) and others to our growing family of investors.

This is a big milestone for our team and our community. We wanted to share our progress and what the future holds for Raycast:

Digital workspaces are broken. We spend too much time on busy work and are driven by notifications instead of motivations. Information is scattered across apps, and browser tabs fight for our attention. Our energy is drained by things that don't matter, and we finish our workdays feeling we haven't accomplished anything. This makes work stressful.

We built Raycast to calm down our workspaces and make interacting with tools effortless. For this, we've released many new features throughout the last year: Quicklinks let you seamlessly navigate the web and your computer. Snippets speed up your writing by inserting frequently used text. Clipboard History makes copied content searchable. Window management keeps your desktop tidy. The list goes on and on. These features made Raycast an indispensable tool for thousands of developers and designers.

Our platform is a new chapter for our community. From the get-go, we knew that we couldn't build all the extensions ourselves. Productivity is too personal. People use different tools and have distinct workflows. With our API, we make it easy to build the perfect productivity tools. You can use React and Node.js to create extensions with minimal effort, while keeping native performance and UI. Our Store allows you to discover extensions directly in Raycast and share them via a link with our community. It has never been easier to create and distribute a magical desktop experience. And we're just getting started.

A lot of highly-rewarding productivity tools are custom to the setup of teams. Some of those setups are even behind intranets or firewalls. Building internal tooling is hard. It often ends up in custom solutions, which are cumbersome to maintain and inconvenient for new joiners to learn. This leaves a ton of productivity untapped. We have a unique opportunity to become the internal tool for teams. Millions of developers can build something with our API without learning anything new in a tool that they are already familiar with. This will profoundly change how high-performing teams speed up their processes even further.

Not only does our product stand for efficiency, but our company does too. We ship updates every week, value quality over quantity, and eliminate bureaucracy to create a workplace where makers shine. We have a tight-knit team that rocks. Now, we're taking this to the next level and aim to become the hottest workforce in Europe. If you like what you've just read, say [hello](https://raycast.com/jobs).

All of this wouldn't be possible without our amazing [community](https://raycast.com/community). They motivate us to do better work, hold us accountable when we ship bugs, and guide us to build the best app. Thank you for being part of our journey. We deeply appreciate your help and never take it for granted.

Announcing our platform, Series A and early access to team features

$15M Series A to make work frictionless

At Raycast, Designers will create new designs in Figma, and put together a series of screens for the flow they're working on. Behind the app interface, a gradient color will be applied to give the impression of the real thing, and the app being used in context.

Those placeholder wallpapers ocassionally get turned into wallpapers for our desktops (sometimes spotted in our Friday demo's), and so we made a repository for some of them to be shared and downloaded with you, our community.

<Media src="/uploads/wallpaper-blog-images/blog-message-01.png" caption="A wallpaper request does not require a ticket on Linear" />

After an overwhelming response to them (both internally, and externally), later down the line we were asked if we could share how we make them. And so here we are.

This is by no means the only way, or the right way. But it's an easy way that we use to create nice, colorful wallpapers. 

<Media src="/uploads/wallpaper-blog-images/blog-tweet-01.png" caption="Our tweet when we launched Raycast Wallpapers" />

<Media src="/uploads/wallpaper-blog-images/blog-tweet-02.png" caption="Jonathan's request" />

## The Guide

What you'll need to get started:

- **A design tool of your choice.** We use [Figma](https://www.figma.com) at Raycast – it's free, and available on Mac or Windows. You can also use [Sketch](https://www.sketch.com), [Adobe XD](https://www.adobe.com/products/xd.html), or [Framer](https://www.framer.com) to name a few.
- **Some colors or inspiration in mind.** It's good to have an idea of the colors you want to blend (not the exact hex codes just yet).
- **A little bit of patience.** It might not be perfect to start with, but moving some bits around and adjusting it as you go will lead you to a nice final result.

## Step One

Create your frame – we usually design the wallpapers for 5K at `5120 x 2880 px`. You can set it at the resolution you're designing for (for example, `1170 x 2532 px` for the iPhone 12 Pro, or `2048 x 2732 px` for an iPad Pro, etc).

Your frame will be used as the base of your wallpaper; think of it as the undercoat when painting a wall. Remember that for later.

<Media src="/uploads/wallpaper-blog-images/blog-image-02.png" caption="Create your wallpaper frame" />

## Step Two

Add a new rectangle shape layer to your frame that fits 100% of the width and height of your frame. In this case, mine is `5120 x 2880 px`. This is where you will apply the gradients and styling to, **not the base**.

<Media src="/uploads/wallpaper-blog-images/blog-image-03.png" caption="Add a rectangle layer" />

## Step Three

Change your solid fill layer to angular (or linear, or radial, it's up to you). This is the best way to blend colors without using too many layers.

<Media src="/uploads/wallpaper-blog-images/blog-image-04.png" caption="Apply a gradient fill to your rectangle shape" />

## Step Four

Now, start adding colors to the gradient palette. This is where your inspiration comes in handy, because you can use the color picker to grab some colors that blend together nicely.

You can see I've added in quite a few. The more you add, the more vibrant, but also the harder it is to make them blend. I would recommend using tones that are similar, or follow one another on the color spectrum.

<Media src="/uploads/wallpaper-blog-images/blog-image-05.png" caption="Add color points to your fill layer" />

## Step Five

With your colors picked, feel free to play around with the the gradient angle, size, and position of the colors. You'll need to be patient, as this can take some time to feel right.

You can see in my example, I've pushed 5 out of 7 colors together, and moved the center point off to the left. This adds some complexity to the overall look.

I've also enlarged the rectangle size from it's original 5K resolution we started with. This is to make sure there's no edges bleeding in to the base in the final outcome.

<Media src="/uploads/wallpaper-blog-images/blog-image-06.png" caption="Move around the colors and reposition the gradient" />

## Step Six

The penultimate step is to add a layer blur to the styled layer. This helps blend the colors together even more. The gradient does it to some extent, but the additional layer blur fuzes it together that little extra bit that it needs.

I've used an `800px` blur as the layer effect. You can increase or reduce the amount, depending on how much you think it needs to be blended.

<Media src="/uploads/wallpaper-blog-images/blog-image-08.png" caption="Apply a layer blur to your rectangle shape" />

<Banner>At this stage, you can add a solid fill to the frame canvas. It helps make sure there's no transparent bleeding around the edges if you haven't resized the rectangle shape enough. In this case, I would apply a dark purple color that works well with the palette.</Banner>

## Final Step

And that's it. When you're happy with the composition and the overall look and feel of your wallpaper, export your frame and apply it to your desktop. This could take a few tries, as you notice some things you want to improve, or the edges don't quite blend as well as you'd like after applying the layer blur. That's where your third requirement comes in place: patience.

<Media src="/uploads/wallpaper-blog-images/blog-image-final.png" caption="Raycast looking great and glowing" full />

## Get More Wallpapers

[Check out this wallpaper](/wallpapers#moonrise) and see our other set of wallpapers [here](https://raycast.com/wallpapers).

If you'd like to share yours in our repository, mention us on Twitter, and we'll add it and credit you as the author. Have fun making your own!

Here's our 6 step guide on how you can make your own Raycast wallpaper for your desktop (or even your mobile and tablet).

Making a Raycast Wallpaper

At Raycast, we do not require code reviews. Engineers push to the main branch and request reviews when they think it's necessary. In this blog post, I outline how we built an engineering culture that is based on trust and allows us to move incredibly fast.

## The beginning

When Petr and I started Raycast, we were sitting next to each other in the same flat for three months. Every day, we built features to iterate as fast as possible to something users want. At this time, we didn't do any code reviews and trusted each other blindly. If there was a technical question, we solved it in person, committed the code to the main branch and moved on to the next problem.

When we started to grow our distributed team, we asked ourselves if we should adopt code reviews. Common wisdom tells you that pull requests are best practice in high-performing engineering teams. But we liked the trust, collaboration and speed of our "process" and decided to **_not_** require code reviews. Instead, every engineer has the right to push their changes to the main branch. They can request a review if they want somebody else to take another look at their code. Sometimes this happens after the change has landed in the trunk.

## Responsibility over convention

We use GitHub for source control, which comes with the concept of pull requests (PR) for code reviews. Typically, an engineer works on a task and then proposes their changes to the repository. After a discussion and potential changes, the engineer merges their changes into the base branch. This model works great for open source and allows strangers to contribute to projects. However, we found it impractical for our team for a few reasons:

- **Pull requests discourage trust.** Proposing every code change that somebody else has to approve doesn't feel encouraging for teams that should operate with a high degree of trust. There are more efficient ways to collaborate on code.
- **Pull requests don't prevent bugs.** Reviewing code is hard! You can catch obvious mistakes, but you won't have consistent in-depth scrutiny. Many issues reveal themselves only after extensive use, which doesn't happen during code reviews. We rely on fast iterations with [user feedback](/blog/feedback/).
- **Pull requests slow down.** Code reviews aren't high priority for engineers. They have to make time to clean up their review queue. In reality, PRs are an afterthought and not what you want to spend your time on as an engineer.

We value [full responsibility](/jobs#what-we-offer) and all our engineers own features from ideation to maintenance. Our engineering culture reflects this by giving engineers the freedom to push to the main branch and only request code reviews if they think it's necessary.

## How does this work in practice?

Our goal is to dogfood changes as quickly as possible. For this, everybody works on the main branch. This produces a constant stream of changes that can be immediately tested by others. Our continuous integration builds and tests every commit. In addition, we trigger an internal release every night which includes all changes that got committed during the day. Each release is automatically installed for the entire team. This allows us to test new changes within 24 hours.

The daily internal releases make it simple to collect a lot of feedback to iron out bugs or usability issues. If the team is happy with the quality of a feature, it gets released as part of our next public release. If it needs further iterations, we use a feature flag to keep it internal. This workflow helps us to consistently ship [updates every other week](/changelog).

<Banner>Side note: We use rebase instead of merge to keep a much cleaner project history and eliminate unnecessary merge commits.</Banner>

There are some situations when we request code reviews. If we touch a new part of the codebase, we open a pull request. A good example for such a change is adding a database migration for the first time. Nobody wants to screw up the production environment and rather double checks it. Often new team members request code reviews for the first couple of weeks to familiarize themselves with our codebase. Over time, they gain confidence to work on bigger changes and start pushing to the main branch directly. 

It doesn't always have to be a PR. Sometimes it's enough to make a teammate aware of a particular change with a "post-commit message". After somebody committed their change, they link the relevant person in a Slack channel that is subscribed to our repository or on the commit on GitHub itself. This is useful for changes that could affect the work of others. This is also a great way to avoid blocking code reviews due to time differences. If there is some problem that needs the input of multiple engineers, we hop on a quick [Around](https://www.around.co/?ref=raycast) video call and use screen sharing to collaborate. This is handy to sort out bigger topics such as refactoring parts of the codebase or aligning on features that depend on each other.

We found this way of working more effective. It avoids isolated work on long-lived branches and creates momentum through the continuous updating of the app.

## Make your own rules

Every company or team is different, but one thing is the same: They all want to build the best product in the shortest time possible. There are different ways to achieve this. Ours is to bet on our team and give all engineers the trust to do their best job. This includes letting them decide whenever they want their code reviewed by somebody else. This might be not the right process for other teams that have more strict security requirements. So far, this works well for us. It allows us to rapidly iterate on features, attract great engineers who want to tackle big problems, and establish an asynchronous communication culture that fits our fully distributed team. 

It's up to you and your colleagues to set the rules for your team. Don't adopt best practices in a dogmatic fashion. Rather, ask yourself if the circumstances of others apply to you. There is a high chance that they won't, and you find a more suited way to do things.

How we built an engineering culture based on trust that allows us to move incredibly fast without requiring code reviews.

No code reviews by default

Faye Sipiano

At Raycast, we know that developers value their productivity over processes. Who could be better at knowing what makes you productive than you? Don't let clunky workflows slow you down - write scripts, add them to Raycast, and let Raycast take your system through the steps rather than you having to manually do it. [Script commands](https://github.com/raycast/script-commands) automate your own personal workflows and help in managing the continuous context switching that comes with being a developer.

## What will Raycast do with scripts?

Raycast executes your local scripts and enables you to perform frequent and useful commands without having to open a terminal window. Your script commands will be beautifully integrated in our UI focused design. Using scripts means that you can instruct your computer to perform a set of instructions, as well as when and how it should do it. We have some great script examples as well as some [templates](https://github.com/raycast/script-commands/tree/master/templates) to help you get started in our repository.

Let's take a look at a small but useful script. GitHub is a well-used tool for most developers. We think that checking for pull requests could be smoother - here is the current process:

1. Load up your browser
2. Click in the search bar
3. Type *Github*
4. Load the page
5. Select *Pull Requests*

If you are on a busy team, or responsible for a critical repo in your organization, then the need to constantly check on your pull requests manually could get very tedious. With just a template and one line of code, we can take this multi-step process down to a single keystroke:

```bash
#!/bin/bash

# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Open Pull Requests page
# @raycast.mode silent
#
# Optional parameters:
# @raycast.packageName GitHub
# @raycast.icon images/github-logo.png
# @raycast.iconDark images/github-logo-iconDark.png

open https://github.com/pulls/
```


All scripts have parameters to instruct Raycast on how to process and output your request. You can read more about them [here](https://github.com/raycast/script-commands#standard-output). In the example, we have set the `@raycast.mode` parameter to `silent`, which means that the script will run instantly and silently, allowing you to access the newly opened page when you are ready.

Of course, you could change the URL and re-purpose this script for any workflow you wanted such as opening Notion pages, favourite news sites, or social medias.

By assigning a hotkey, you can speed up your workflows even further:

<Media src ="/uploads/add-hotkey.png" caption=" Adding a hotkey allows for fast access to your script"/>

## So far, so good!
This is a great first step, especially with the addition of the hotkey... but let's say that you are part of a busy team and want to speed up your workflows further, or maybe you are responsible for multiple repos and you want to tailor this script to give you exactly what you need without any fuss.

We can take the script functionality further and utilise the `@raycast.mode inline` parameter - this will display the data in an easy to access way and allows you to check statistics with a keystroke.



```ruby
#!/usr/bin/env ruby

# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Open Pull Requests
# @raycast.mode inline
#
# Optional parameters:
# @raycast.packageName GitHub
# @raycast.icon images/github-logo.png
# @raycast.iconDark images/github-logo-iconDark.png
#
# Conditional parameters:
# @raycast.refreshTime 5m

require 'json'
require 'net/http'
require 'uri'

# Insert a personal access token (https://github.com/settings/tokens)

API_TOKEN = ''

if API_TOKEN.empty?
 puts 'No API token provided'
 exit(1)
end

RED = 31
GREEN = 32
YELLOW = 33

uri = URI('https://api.github.com/graphql')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = "token #{API_TOKEN}"
req.body = '{ "query": "query { viewer { pullRequests(first: 10, states:OPEN) { nodes { title number url } } } }" }'
req_options = {
 use_ssl: uri.scheme == 'https'
}

res = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
 http.request(req)
end

if res.code == '200'
 result = JSON.parse(res.body)
 pull_requests = result['data']['viewer']['pullRequests']['nodes']

 if pull_requests.length == 0
 message = "No open pull requests 🎉"
 puts "\e[#{GREEN}m#{message}\e[0m"
 else
 color = (pull_requests.length <= 5) ? YELLOW : RED
 message = "You have #{pull_requests.length} open pull requests"
 puts "\e[#{color}m#{message}\e[0m"
 pull_requests.each do |pr|
 puts "##{pr['number']} #{pr['title']} (#{pr['url']})"
 end
 end
else
 puts 'Failed loading GitHub pull requests'
 exit(1)
end
```

This is a slightly more complex script, utilising both the `inline` parameter and the `refreshTime` parameter. Let's break down what this means:

1. Firstly, we set the dependencies and parameters: Inline means that the data will be displayed in an easy-to-read format on the Raycast root search (the home screen), enabling you to access your data and required statistics. `Inline` mode is ideal for allowing quick access to smaller data sets. Existing examples built by our community include [timezones](https://twitter.com/thomaspaulmann/status/1359893707961597957?s=20), statistics, and [stock portfolios](https://twitter.com/thomaspaulmann/status/1361351789052846081?s=20).
2. The `refreshTime` parameter is set to 5 minutes for this script. This means that Raycast will automatically run your script in the background every 5 minutes to check for updates; your data will be refreshed and ready for you to view without you having to do anything. You can view the details of this parameter [here](https://github.com/raycast/script-commands#api).


<Media src="/uploads/add-to-favourites.png" caption="Add your script to favourites to pin it to the top of the home screen, ready to view"/>


## More detail

What if you want to see more data that could fit into `inline` mode? Raycast can handle that too.
Let's quickly write a Ruby script to utilise Raycast's `fullOutput` mode to view all of your pull requests in more detail. We support up to 3 arguments to further expand the capabilities of your scripts.

```ruby

 #!/usr/bin/env ruby

# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Show Open Pull Requests
# @raycast.mode fullOutput
#
# Optional parameters:
# @raycast.packageName GitHub
# @raycast.icon images/github-logo.png
# @raycast.iconDark images/github-logo-iconDark.png

require 'json'
require 'net/http'
require 'uri'

# Insert a personal access token (https://github.com/settings/tokens)

API_TOKEN = ''

if API_TOKEN.empty?
 puts 'No API token provided'
 exit(1)
end

uri = URI('https://api.github.com/graphql')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = "token #{API_TOKEN}"
req.body = '{ "query": "query { viewer { pullRequests(first: 10 states: OPEN) { nodes { baseRepository { name } title number url } } } }" }'
req_options = {
 use_ssl: uri.scheme == 'https'
}

res = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
 http.request(req)
end

if res.code == '200'
 result = JSON.parse(res.body)
 pull_requests = result['data']['viewer']['pullRequests']['nodes']

 if pull_requests.length == 0
 puts 'No open pull requests 🎉'
 else
 puts "You have #{pull_requests.length} open pull requests"
 pull_requests.each do |pr|
 puts "##{pr['number']} #{pr['title']} (#{pr['url']})"
 end
 end
else
 puts 'Failed loading GitHub pull requests'
 exit(1)
end

```

Raycast can easily be configured to display larger data sets, so you'll always have all of the information you need at your fingertips, ready to view. As we have the URLs of the pull requests now, you can press `⌘` `L` to get an overview of links in the output which makes it easy to open a specific pull request.

<Media src= "/uploads/showPRdetail.mp4" caption= "FullOutput mode lets you display larger data sets" video full />

## Let's wrap up

By spending a few minutes putting together scripts for your common workflows, you can customize your experience and harness the power of Raycast. We are focused on high-quality UX and want you to have a smooth experience with beautiful UI for any task and with any tool.

Rather than leaving all tabs open in the evening to return to the next day, you could write a script that opens commonly visited sites with just a keystroke.

You can view all API and parameter documentation on our [GitHub page](https://github.com/raycast/script-commands#api). Feel free to browse and try out our [community-built scripts](https://github.com/raycast/script-commands/tree/master/commands#raycast-script-commands), you are welcome to fork and customize them to your needs, or try building your own!

You can find all scripts written in this blog post [here](https://github.com/raycast/script-commands/tree/master/commands/developer-utils/github).

Raycast lets you put productivity ahead of your development processes and workflows.

Getting started with script commands

The first two pieces of advice you get after joining a YC batch are _launch early_ and _talk to your users_. Both will help you to make something people want. At Raycast, we’re obsessed with user feedback. We read and answer each message that we receive. We value it more than metrics, and it’s one of our ways to collaborate with our community to shape Raycast.

> *"Amazing response speed. You are the only app I write feedback for. You are actually listening and helping."* - by [Antonio Stoilkov](https://twitter.com/antoniostoilkov)

For us being obsessed with user feedback doesn’t mean to collect and instantly forget about it. It means treating feedback as a conversation, act on it and close the loop. In this post, I’ll outline how we run our feedback loop at Raycast and what we’ve learned so far.

## Make it easy to reach you

It should be easy and quick for a user to send feedback. Nobody wants to go through a five-step questionnaire to report a small bug. Instead, we provide a command to send feedback from within Raycast. During onboarding, we hint the *Send Feedback* command to new users to make sure they know how to contact us.

<Media src="/uploads/send-feedback-command.png" />

The command is a simple form with a plain text description and an optional email address. We don’t differentiate bugs, feature requests or general feedback. This is on purpose. We want to make it as seamless as possible to reach us. The email allows us to respond, ask follow-up questions and keep a history of previous submissions. 

<Banner>Note: We don’t require a login to use Raycast. We leave the choice to the user if they want us to get in touch with them. Most people do provide an email with their feedback.</Banner>

In addition to our built-in feedback form, we use our [Slack community](https://raycast.com/community) to collect feedback. Usually, users join our community after they’ve used the app for a few days. They are motivated to exchange ideas and Slack makes it easy to add more context. However, communication in Slack is different. People expect quick responses, and it’s no-longer a 1-to-1 conversation. Other community members can chirp in to upvote feedback or provide answers. Played well, this can foster a feeling of belonging.

Slack offers direct messages which are great to deepen the relationship with your power-users. I chat with [Thiago](https://twitter.com/tholanda), one of our early community members, at least once a week. Many ideas pop up during these chats. One idea was to generate the documentation of our [script commands](https://github.com/raycast/script-commands). Eventually, Thiago went ahead and built it himself. This isn’t so much about bug reports or feature requests any more. This is more about how can community members contribute from the outside to Raycast. And this benefits the community as a whole.

There is a caveat of having a community on Slack: People expect quick responses which can easily distract the team. For this, we’ve introduced an on-call rotation to sort out and respond to feedback.

## Act on feedback

Each week, another person of the team reads, filters and replies to every piece of feedback. All messages from the app get send to a shared inbox in [Front](http://frontapp.com). This allows the on-call to collaborate with the feature owner on a response. Additionally, we persist each feedback to a database in [Airtable](http://airtable.com). This allows us to query it later. 

At the beginning, we sent everything in real-time to a Slack channel. It turned out that this was very distracting for our team. Now, we batch the feedback of the last 24 hours in a daily digest. The digest is automatically posted in the morning. This way, everybody can stay on top of the received feedback without getting distracted throughout the day. It’s important to us, that every team member has access to the feedback for two reasons: 

1. Feature owners should know when something is broken in order to decide if it should be fixed in the next release, or if a fix can be prioritized later.
2. The constant stream of feedback makes us aware of what’s missing, which then influences our work for the next month ([See previous blog post about how we plan our work](https://raycast.com/blog/focus-document)). 

Some of our most-used features are based on feedback from our community members. For example, many users asked for a global hotkey to toggle the clipboard history. They were used to it from other apps. After hearing this feedback over and over again, we addressed it in a generic way. Now, users can assign global hotkeys to perform a command or open an app. 

## Close the loop with the sender

Don’t treat feedback as one way! When somebody takes the time to send you a bug report or suggest a new feature, you should respond. Our on-call’s job is to respond to feedback within 48 hours, even quicker in Slack. We want to make our users feel heard and encourage them to keep providing feedback. 

It’s crucial to be honest with your users. If we receive a suggestion that we won’t build, we let them know. We want to set the right expectations. If they share our opinion and adopt the tool, that’s great. If they stop using the tool, that’s fine as well. You can’t build for everyone but you can stay flexible. We declined some suggestions initially, and after they came up more often, we decided to build them anyway. 

> *"Awesome shipping tempo, keep it up!"* - by [Brian Lovin](https://twitter.com/brian_lovin)

In addition to responding to the feedback directly, we have a few other mechanisms to close the loop. We keep a [changelog](https://raycast.com/changelog) that lists new features, improvements and bug fixes for each update. We share each changelog entry in our [Slack community](https://raycast.com/community) and on [Twitter](https://twitter.com/raycastapp). This makes it easy to follow our progress on the channels that our users already use. And for the folks that prefer email, we send a semi-regular newsletter that highlights recently released features and other tips.

## Wrapping up

As mentioned in a [previous blog post](https://raycast.com/blog/focus-document), we don’t keep a backlog or have a roadmap. We try to stay flexible to fulfil the needs of our users. The user feedback guides us what to build in the short term. Our limited set of metrics help us go in the right direction in the long term.

A working feedback loop is based on trust. The quicker you address a bug report, reply to a feature suggestion or answer a support question, the more trust you gain. You build more trust with every positive interaction, and at some point you have collected enough to become friends with your user. And if that happens, you won somebody that cheers for you and spreads the word about you but also tells you when you screwed up.

Instead of relying heavily on analytics, we collaborate with our community and read every piece of feedback to figure out what to build next. Here is what we've learned so far.

Be obsessed with feedback, not metrics

During day-to-day work of an early stage company it's easy to fall into a reactive mode where you want to fix all the feedback and bugs that pop up. I get it and we've been there. It feels very tempting and can be almost addictive. Don't get me wrong, we’re obsessed with user feedback, and you should be as well, but only to a certain degree. It's equally important to have a system in place that allows you to work on bigger projects. Projects that take multiple weeks and move the needle the most. For us, this system is writing monthly focus documents.

Every beginning of the month, we write down what we work on for the next 30 days. We call these one-pagers focus documents, and they help us to spend time on the right things. With the document, we make sure that our fully distributed team aligns on direction and ownership. Everybody on our team is responsible for at least one project throughout the month. They should always know on *what* they're working and *why* they're working on it.

## Structure

Each document starts with a summary that describes the goal for the month. We don't specify any metrics or growth goals. By this point, we already know what we want to achieve and describe the projects that we bet on. The summary may include a review of the previous month to set the context. Next, is a list of projects. Each project includes an owner, a link to a Linear project and a description. 

<Banner>Use <a href="https://www.notion.so/raycastapp/Focus-for-Month-2021-7389bab7d0944ba88e0307f9cc6f9815">this Notion template</a> for your first focus document.</Banner>

The first sentence of the description states *what* we want to build. The rest describes *why* we want to do it. The owner is responsible for *how* to finish the work and has the authority to drive the project. Sometimes, the Linear project is pre-filled with user feedback. Otherwise, the owner has the freedom to keep track of their work however they want. Some do it more granularly, others do it high-level. We care about the outcome and trust the individual to manage themselves. We don't follow any religious agile processes. 

## Unplanned work

The monthly focus document acts as a guidance on what’s important, but you can’t plan everything ahead. There is always some unplanned work popping up that needs attention. We read every single user feedback and try to respond to each of them (a topic for another blog post). With the focus documents, we established a clear ownership of features. If it’s an easy bug that the owner of the feature knows how to resolve, we aim to address it with the next release. If it’s a bigger thing, we decide if it’s more important than the planned work or should be left for later. The advantage when you read all your feedback is that you get an intuition for topics that pop up more often. If it’s something that popped up many times before but was too disruptive to address right away, we try to plan it for the next month. This way we can keep a calm backlog and stay flexible while focusing on a set of goals.

## Growing team

By the time of writing this article, our team size was five, and we're hiring. It's going to be interesting to see how the concept of monthly focus documents will work in a bigger team. So far, it has proven as a valuable way to establish trust, ownership and direction across our distributed team. 

<Banner>Bonus for funded startups: Use your monthly focus documents for your investor updates. Our updates are a summary of the document mixed with highlights, lowlights and metrics.</Banner>

Generally, doing trumps planning for young startups. However, when you have to write down what you’ll work on, it forces you to make compromises because there is only a limited amount of time and resources available. You can’t know everything upfront, but you should try your best to get ahead of what’s important. While writing your first focus document, ask yourself how you would feel if you have everything accomplished from your list at the end of the month. It will help you to make the right choices.

Try it out yourself and let us know how it works for your team.

As an early-stage company you have to move fast and stay flexible to be successful. Focus documents are a lean way to balance execution and planning of product teams.

Monthly focus documents instead of roadmaps

Our number one feature request for Script Commands was inputs. With them, developers can alter the logic of a command without requiring the user to change the code of a script. We wanted to make sure that inputs fit into Raycast. This includes two important aspects:

1. It should be intuitive to adopt a command by others. No help should be required to understand the inputs.
2. It should be easy for the developer to specify inputs. They should concentrate on the solution they want to deliver.

## The basics

What we came up with are typed arguments. Similar to our other parameters, they are defined in a comment at the top of a script. Here is an example:

```bash
#!/bin/bash

# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Search in Google
# @raycast.mode silent

# Optional parameters:
# @raycast.icon 🔎
# @raycast.packageName Web Searches
# @raycast.argument1 { "type": "text", "placeholder": "query" }

open "https://www.google.com/search?q=${1// /%20}"

```

The above script command requires one argument of the type `text`. For now, we only support `text`. Later, we'll introduce more types such as URLs and enums. This is how the command looks in Raycast:

<Media src="/uploads/script-single-argument.png" caption="Script command with single argument" />

Raycast uses the placeholder of an argument to hint the user what to enter. When the script is executed, all arguments are parsed and forwarded to the script, giving the developer full flexibility to interpret them. Continuing the example from above, the text argument is used as query for a search in Google.

## Advanced example

We support up to three arguments. Specify them as additional parameters:

```bash
#!/bin/bash

# Required parameters:
# @raycast.schemaVersion 1
# @raycast.title Add to Things
# @raycast.mode silent

# Optional parameters:
# @raycast.icon images/things.png
# @raycast.packageName Things
# @raycast.argument1 { "type": "text", "placeholder": "Title" }
# @raycast.argument2 { "type": "text", "placeholder": "When (e.g. \"today\")" }

open "things:///add?title=${1// /%20}&when=${2// /%20}"
```

URL schemes are a great way to send commands to other apps. The above script uses two arguments to add a new todo to [Things](https://culturedcode.com/things/). The placeholder describes the usage of each argument. In this case, the first argument is the title of the new todo. The second argument is a date time string for a reminder. This is how the command looks in Raycast:

<Media src="/uploads/script-multiple-arguments.png" caption="Script Command with multiple arguments" />

Our UI makes it clear what each argument does. A user can tab between the arguments and executes the script with `↵`.

## Pro mode

We made sure that Script Commands that require arguments fit into the rest of Raycast. They work especially well with aliases.

<Media src="/uploads/script-single-argument-amazon.mp4" caption="Use Script Commands with aliases" video full />

If you define an alias for your Script Command, you can type the alias, followed by a space to select the first required argument. This allows to rapidly search for something on Amazon — just type "am \{your query\}".

You can also assign a global hotkey to your Script Commands. When you press the hotkey, Raycast selects the first required argument and you can start typing.

<Media src="/uploads/script-alias.png" caption="Shortcuts for Script Commands" />

Check out our [public repository](https://github.com/raycast/script-commands) full of handy Script Commands. We welcome contributions and are curious to see what you build with the new arguments.

## Wrapping it up

Typed arguments express the required inputs of a Script Command intuitively in Raycast. Equally, they make it easy for developers to specify what their scripts require. With additional types, we believe typed arguments lower the burden of running CLI tools. 

Watch out for more to come!

Make your Script Commands more flexible with typed arguments.

Inputs for Script Commands

[Script Commands](https://github.com/raycast/script-commands) let's you tailor Raycast to your needs. Combined with Swift and some of Apple's frameworks, they are a powerful tool to automate every-day tasks on your Mac. Let's dive into three examples to show what you can achieve with them.

If you haven't [installed](https://github.com/raycast/script-commands#install-script-commands) or [written](https://github.com/raycast/script-commands#write-script-commands) any Script Commands, check out the guides in our repository.

## Quit running applications

Let's say it's the end of the day and you want to tear down your work environment to start binging your favorite series. Why not quitting all your running applications with a few keystrokes?! 

Thanks to Apple's AppKit, we can achieve this with a few lines of Swift code:

```swift
#!/usr/bin/swift

// Required parameters:
// @raycast.schemaVersion 1
// @raycast.title Quit All Applications
// @raycast.mode silent

// Optional parameters:
// @raycast.icon 💥
// @raycast.needsConfirmation true

import AppKit

let finderBundleIdentifier = "com.apple.finder"

NSWorkspace.shared.runningApplications
 .filter { $0 != NSRunningApplication.current }
 .filter { $0.activationPolicy == .regular }
 .filter { $0.bundleIdentifier != finderBundleIdentifier }
 .forEach { $0.terminate() }

print("Quit all applications")
```

Let's walk through the script step by step:

1. We use AppKit's `NSWorkspace` to get an array of all `NSRunningApplication` instances.
2. We filter out the currently running application to not close Raycast. Alternatively, we could do this with the bundle identifier.
3. We're only interested in ordinary apps that appear in the dock and use the `ActivationPolicy` to filter them.
4. The Finder is a special app. We don't want to quit it and use the `bundleIdentifier` property to remove it from the array of running applications.
5. Last step, we iterate over the filtered applications and call `terminate()` to quite them.

After we quit all applications, we print a message that Raycast displays in a toast alongside the icon of the command. The toast informs the user about the successful execution. This is how the command looks in action:

<Media src="/uploads/quit-all-applications.mp4" caption="Quit all running applications with a script command" video full/>

## Copy your last download

Foundation provides easy access to the file system with the `FileManager` APIs. Let's use it to quickly copy the last download. This makes it convenient to share it with your team-mates in the messenger of your choice.

```swift
#!/usr/bin/swift

// Required parameters:
// @raycast.schemaVersion 1
// @raycast.title Copy Last Download
// @raycast.mode silent

// Optional parameters:
// @raycast.icon 💁

import AppKit

// MARK: - Main

guard let download = latestDownloadURL() else {
 print("No recent downloads")
 exit(1)
}

copyToPasteboard(download)
print("Copied \(download.lastPathComponent)")

// MARK: - Convenience

func latestDownloadURL() -> URL? {
 guard let downloadsDirectory = FileManager.default.urls(for: .downloadsDirectory, in: .userDomainMask).first else { return nil }
 return try? FileManager.default
 .contentsOfDirectory(at: downloadsDirectory, includingPropertiesForKeys: [.addedToDirectoryDateKey], options: .skipsHiddenFiles)
 .sorted { $0.addedToDirectoryDate > $1.addedToDirectoryDate }
 .first
}

func copyToPasteboard(_ url: URL) {
 NSPasteboard.general.clearContents()
 NSPasteboard.general.writeObjects([url as NSPasteboardWriting])
}

extension URL {
 var addedToDirectoryDate: Date {
 return (try? resourceValues(forKeys: [.addedToDirectoryDateKey]).addedToDirectoryDate) ?? .distantPast
 }
}
```

Ok, what happens here?! The script is split into a main and convenience part, separated by the marks. In the main part, we grab the latest download, copy it to the pasteboard and display a message to the user — Fairly straight forward. Let's look into the convenience part:

1. The `latestDownloadURL()` method uses the `FileManager` to get the contents of the downloads directory. It sorts the files by the date they got added. The sorting is achieved with an extension on `URL` that exposes the `addedToDirectoryDate`. The last step is to return the `first` URL of the array.
2. We want to copy the download to the pasteboard to let users quickly insert it into other applications. This can be done with the `NSPasteboard`. First, we clear the contents of the pasteboard, followed by writing the URL of the download as an object to the pasteboard. 

Now you can execute the new command from Raycast and hit `⌘` `V` to paste your last download in any other application, like this:

<Media src="/uploads/copy-last-download.mp4" caption="Copy the last downloaded file and share it via Slack" video full/>

## Share your availability

Another handy framework from Apple is `EventKit`. It provides access to the system calendar to handle events and reminders. Let's use the framework to copy our availability. This way, the next time a colleague asks you for a virtual Zoom coffee, you just execute the command and respond.

```swift
#!/usr/bin/swift

// Required parameters:
// @raycast.schemaVersion 1
// @raycast.title Copy Availability
// @raycast.mode silent

// Optional parameters:
// @raycast.icon 📅

import AppKit
import EventKit

// MARK: - Main

let now = Date()
let startOfToday = Calendar.current.startOfDay(for: now)
let endOfToday = Calendar.current.date(byAdding: .day, value: 1, to: startOfToday)!

let eventStore = EKEventStore()
let predicate = eventStore.predicateForEvents(withStart: startOfToday, end: endOfToday, calendars: nil)
let eventsOfToday = eventStore.events(matching: predicate).filter { !$0.isAllDay }

let availability: String
if eventsOfToday.isEmpty {
 availability = "I'm available the full day."
} else if eventsOfToday.allSatisfy({ $0.endDate.isAfternoon }) {
 availability = "I'm available in the morning."
} else if eventsOfToday.allSatisfy({ $0.endDate.isMorning }) {
 availability = "I'm available in the afternoon."
} else {
 let busyTimes = eventsOfToday.map { $0.startDate...$0.endDate }
 
 let availableTimes = availableTimesForToday(excluding: busyTimes)
 let prettyPrintedAvailableTimes = availableTimes
 .map { (from: DateFormatter.shortTime.string(from: $0.lowerBound), to: DateFormatter.shortTime.string(from: $0.upperBound)) }
 .map { "* \($0.from) - \($0.to)" }
 .joined(separator: "\n")

 availability = "Here's my availability for today:\n\(prettyPrintedAvailableTimes)"
}

copy(availability)
print("Copied availability")

// MARK: - Convenience

extension DateFormatter {
 static var shortTime: DateFormatter {
 let dateFormatter = DateFormatter()
 dateFormatter.dateStyle = .none
 dateFormatter.timeStyle = .short
 return dateFormatter
 }
}

extension Date {
 var isMorning: Bool { Calendar.current.component(.hour, from: self) <= 11 }
 var isAfternoon: Bool { Calendar.current.component(.hour, from: self) >= 12 }
}

func availableTimesForToday(excluding excludedTimes: [ClosedRange<Date>]) -> [ClosedRange<Date>] {
 let startOfWorkDay = Calendar.current.date(bySettingHour: 9, minute: 0, second: 0, of: startOfToday)!
 let endOfWorkDay = Calendar.current.date(bySettingHour: 17, minute: 0, second: 0, of: startOfToday)!
 let workDay = startOfWorkDay...endOfWorkDay

 let busyTimes = [startOfToday...startOfWorkDay] + excludedTimes + [endOfWorkDay...endOfToday]
 var previousBusyTime = busyTimes.first
 var availableTimes = [ClosedRange<Date>]()
 for time in busyTimes {
 if let previousEnd = previousBusyTime?.upperBound, previousEnd < time.lowerBound {
 var newAvailability = previousEnd...time.lowerBound
 if let lastAvailability = availableTimes.last, newAvailability.overlaps(lastAvailability) {
 newAvailability = newAvailability.clamped(to: lastAvailability).clamped(to: workDay)
 availableTimes.insert(newAvailability, at: availableTimes.count - 1)
 } else {
 newAvailability = newAvailability.clamped(to: workDay)
 availableTimes.append(newAvailability)
 }
 }
 previousBusyTime = time
 }

 return availableTimes
}

func copy(_ string: String) {
 NSPasteboard.general.declareTypes([NSPasteboard.PasteboardType.string], owner: nil)
 NSPasteboard.general.setString(string, forType: NSPasteboard.PasteboardType.string)
}
```

This is a slightly more complex script. Let's go through it from the top to the bottom:

1. To start, we use the `EKEventStore` to query all events of today. We filter out all-day long events.
2. Then, we check the array of `EKEvent` and handle common cases for no events and events only in the morning or afternoon. We generate a nice message that we can copy to the clipboard at the end of the script.
3. If there are events spread throughout the day, we calculate the available times and format them in a pretty message. For this, we map the range of busy times and pass them to the helper method `availableTimesForToday()`. Inside the helper, we add some more ranges for non-working hours. Then we can iterate over all busy times and convert them to available time slots. We make sure to handle overlapping ranges accordingly and return an array of all available times throughout the current work-day.
4. The last step is to copy the availability to the clipboard and display a message. 

Here is how you can use it:

<Media src="/uploads/copy-availability.mp4" caption="Share today's availablitliy via Slack" video full/>

## Wrap up

Swift is a great programming language to automate small tasks in your daily workflow on macOS. Raycast puts these scripts at your fingertips and you execute them from anywhere on your desktop. You can take it one step further, and assign a global hotkey to your script command. This way, you can press a keyboard shortcut to execute your script, e.g. assign `⌘` `⌥` `Q` to quit all applications in Raycast. 

All scripts of this blog post are available in our [official repository](https://github.com/raycast/script-commands). Try them out and feel free to fork them to adjust to your needs and contribute to our growing catalog of script commands.

Write Script Commands in Swift to trigger every-day tasks from Raycast.

Automate your Mac with Swift

At **Raycast**, we make developers more productive. We believe that the ever-growing jungle of SaaS tools that companies rely on, do more harm than good to a developer’s day. The continuous context switching between browser tabs to fix bugs, keep co-workers updated, or find information ruins the creation flow.

<Media src="/uploads/screenshot-jira-open-issues-dark.png" />

We provide developers an escape path from this jungle with a command line inspired interface for quickly accessing their tools. For the last 9 months, we have been crafting Raycast and we are excited to share three announcements today:

1. **Public Beta:** We’ve worked together with a limited number of beta users. During that time we’ve iterated on the user experience and built foundational extensions such as Jira, GitHub and G Suite amongst others. Today, we make Raycast universally accessible to everyone! The app can be downloaded for free as long as we are in public beta.
2. **Seed Round:** We have raised a $2.7 million seed round led by Andrei Brasoveanu from Accel! We’re thrilled to be part of the Accel family with their long history of backing start-ups whose mission is to improve the developer experience. Other investors are Y Combinator, Chapter One, Charlie Cheever (Co-Founder of Expo & Quora), Calvin French-Owen (Co-Founder and CTO of Segment), Manik Gupta (Former CPO of Uber), Zach Holman (Startup advisor and early GitHub engineer) and more.
3. **Developer Program:** A lot of highly-rewarding productivity tools are custom to the setup of individuals, teams or organizations. To support such setups, we’re building an API that allows developers to automate their workflows and we're aiming at establishing a community around it. From today on, we accept signups for the developer program and can’t wait to push Raycast to the next level with developers around the world.

This is a big milestone for our team and we wanted to share our progress and what the future holds for Raycast:

How we build software has changed tremendously during the last decade. Our personal experience at fast-growing companies showed us that following processes has become more important than delivering output. We got frustrated by how much time we spent on tracking bugs, managing sprints, commenting on pull requests, and many other things other than crafting high-quality software.

We realized that our frustration with the tooling is common amongst developers. Most work tools aren’t optimized for powerusers. They are bloated, slow, and miss keyboard shortcuts. And quite often simple things, like closing an issue, takes several minutes. The crux is that employees are trapped with their companies’ tools and can’t migrate to alternatives. Since our announcement of a private beta, thousands of developers have signed up for our waiting list and are eager to level up their productivity!

Raycast provides developers with quick access to their tools. The app cuts through the noise by unifying tools as commands and optimizing efficiency by making them accessible through a few keyboard shortcuts. It already connects with many popular services such as Jira, GitHub, and G Suite amongst others. With Script Commands you can automate your workflows even further.

Because we operate with sensitive data, we took care of privacy in Raycast. The app doesn’t require a login and sensitive data is encrypted on the local hard drive. All API requests go directly to the third party services and we don’t track any sensitive information. Furthermore, Raycast is implemented natively for macOS to deliver the best performance with the least amount of resources. We not only make developers faster, but also don’t slow down their machines.

Today, we're announcing our [developer program](/developer-program) that will provide early API access for building custom extensions. We know that we can’t build all extensions ourselves. But, we can serve the toolkit a developer community needs, to shape the ecosystem of productivity tools they desire.

Thank you for being part of our journey. We deeply appreciate your help and just getting started.

Announcing our public beta, seed round and developer program.

Blog