How did we get here?#

I’ve put my hands on a few programming langauges before including Python, C# and C++. I even had my hands on Go and Rust for a little and made the most rough sketch for imitating the download route and i’ve had to say, i didn’t really enjoy it that much. It felt overly complex and kind of hard to get into, so i dropped the idea and left it for a while before deciding to try it again in July with the most promising looking language, Go.

I decided to take another proper look into the language and did a lot of trial and error. A solid week later i had the first version that i started to understand how things work in Go and started to experiment even more and got down the basics like structs, error handling and modules.

Over the entire month of July, i’ve started to actually enjoy re-coding this project into Go but of course i faced some challenges because things obviously work different than in JavaScript.

NOTE

For the future of this post i’ll be just using TypeScript code in my examples.

The things i’ve noticed#

Getting into Go was interesting because of the way how everything was handled.

1
try {
2
    const response = await fetch(`https://catboy.best/api`)
3
    const data = await response.json() as any
4
} catch (err) {
5
    throw err
6
}

1
req, err := http.NewRequest("GET", "https://catboy.best/api", nil)
2
if err != nil {
3
  panic(err)
4
}
5

6
resp, err := (&http.Client{}).Do(req)
7
if err != nil {
8
  panic(err)
9
}
10

11
defer resp.Body.Close()
12

13
body, err := io.ReadAll(resp.Body)
14
if err != nil {
15
  panic(err)
16
}
17

18
var data map[string]interface{}
19

20
if err := json.Unmarshal(body, &data); err != nil {
21
    panic(err)
22
}

1
type User struct {
2
    ID int
3
    Username string
4
}

1
type User struct {
2
    ID int `json:"id"`
3
    Username string `json:"username"`
4
}

1
var user User
2

3
if err := json.Unmarshal(body, &user); err != nil {
4
    panic(err)
5
}
6

7
//Now you can access things like user.ID and user.Username

1
async function networkTask(): Promise<number> {
2
    await Bun.sleep(1000)
3
    return 1
4
}
5

6
async function ioTask(): Promise<number> {
7
    await Bun.sleep(2000)
8
    return 1
9
}
10

11
//Instead of calling:
12

13
await networkTask() //takes 1 second
14
await ioTask() //takes 2 seconds
15
//Total wait time: 3 seconds
16

17
//you instead use:
18

19
await Promise.all([
20
    networkTask(),
21
    ioTask()
22
])
23
//for a total wait time of 2 seconds since we wait for the slowest to finish loading in parallel.

1
var wg sync.WaitGroup
2

3
func main(){
4
    //instead of:
5
    networkTask()
6
    ioTask()
7

8
    //use:
9
    wg.Add(2)
10
    go func(){
11
        defer wg.Done()
12
        networkTask()
13
    }
14

15
    go func(){
16
        defer wg.Done()
17
        ioTask()
18
    }
19

20
    wg.Wait()
21
}
22

23
func networkTask() int {
24
    time.Sleep(time.Second)
25
    return 1
26
}
27

28
func ioTask() int {
29
    time.Sleep(time.Second * 2)
30
    return 1
31
}

The works#

Anyways, i worked on this Go version a lot and even worked on it during Cavoe’s osu! Event 2025 in August with feedback of a few friends of mine. Shoutout to Marti (you absolute 👑) for letting me use his laptop to actively code on it since i left mine at home.

I managed to cut loading times during routes like audio preview or novideo files, improving them up to a whopping 50x performance increase.

To put some perspective; serving the .osz of the Unforgiving without video took:

• about 5 seconds on Mino Version 4
• 2.5 seconds with multithreading on the unreleased Mino Version 5
• while it got reduced to only 150ms in Go.

you can see similar improvements for audio preview and raw audio serving, which makes it a huge success.

After a lot of testing around with the database, i’ve now decided to take a hybrid approach; Filling meilisearch with only necessary data that is relevant for searching, while storing the full data now in sqlite. Yes, you’ve heard this correctly. I’m using sqlite for a high scale application because Mino actually reads most of the time when it’s not actively crawling from 0, which makes sqlite a perfect fit since it’s lightweight, doesn’t not need to be installed as an extra dependency and is also blazing fast, having a very low response time.

This also made me rethink my approach on my structs because if you ever looked at osu’s api v2, it gets messy really quick. Instead of treating every field in a column i just dynamically store the json as it’s own data field. This way it stays dynamically updated at all times so i always stay compliant with the newest api v2 spec. It also means i don’t need to parse the entire json anymore for each entry, which also saves a little time.

Now if you’ve read the first post of mine, you might ask me: But Nanoo, what about Cheesegull?

Yes, i thought about that, but since i don’t even need most of the fields. Using go’s native unmarshal would be wasteful, because it goes through the entire json. Instead i use gjson and only select the fields i need. (which in my case is about 10 fields out of like 25 or so) and save myself a lot of memory, since i hold less bytes and cpu time.

So far that has been my Journey with Amigo, and i’ll keep you updated.