When watching a replay on Linux, this error comes up with the text:
"An error has occurred
stderr maxBuffer length exceeded"

Once this happens, the Dolphin instance exits.

This is using the AppImage distribution of slippi-desktop-app on Linux. This does still happen with the current version, and if required, I can try building with debugging enabled if possible to help debugging.

Some notes about this error:

• I can skip around the replay without problem.
• I can pause and the replay will not crash.
• It seems that this error is caused after a certain amount of time of the replay being played (After a few tests this seems to be around 1 min and 2 sec)

Some work has already been done in #140 and https://github.com/project-slippi/slippi-launcher/tree/rewrite/basic-ini-manip.

We want the ability to modify gecko codes in the dolphin settings to make it more accessible for users.

I'm trying to use semantic-react-ui's Dropdown menu component to create a file filter in this project. The initial component renders fine, but the menu is invisible when clicked.

The relevant HTML is added to the document but the element is invisible: could this be conflicting with a style configuration I don't know about? (The button is clicked in this example)

And here is a working example with the exact same code outside the project:

https://codesandbox.io/s/semantic-ui-example-w6jro?file=/example.js

TODO Status

• Migrate to ERB
• Improve security using ContextBridge and turning off nodeIntegration
• Replay DB #178
• Relay 2.0

Background

We achieved a lot with the release of Launcher v2. We rewrote everything in Typescript, cleaned up the codebase, added Dolphin auto-installing for Netplay and Playback Dolphin for a unified experience, and rewrote the entire UI with a consistent theme and traditional app layout.

However, there are still some outstanding issues. For example:

• Being dependent on the unmaintained electron-webpack has proved to be a pain point when wanting to upgrade to newer Electron versions.
• Security is quite poor with nodeIntegration enabled everywhere, and not following Electron security best practices

Goals with version 3

With that in mind, we may want to rethink the app once again and aim towards these goals, in-priority order.

New template

ERB is a popular boilerplate which uses Typescript and React, and is built upon Electron 13. In addition, it supports contextBridge out of the box. It does not yet support Typescript inside of the preload.js but we might be able to solve that ourselves. This template has over 18k stars and appears to be well maintained. This could allow us better flexibility and maintainability in the future.

Security first

We should aim to put security first and follow best practices for security in Electron apps. This includes using contextBridge for exposing node functionality, enabling Content Security Policies (CSP), disabling nodeIntegration etc. We should no longer use any node-specific packages inside of the renderer process, and rely only on contextBridge.

File indexer

Update: We probably don't actually need to do this. We can achieve close enough behaviour by doing the following:

• Add a button to re-index in the settings
• Re-index on Replay Browser page load
• Re-index on notification from Dolphin that a file is done writing to (WIP: Dolphin does not have this ability to communicate with the launcher just yet)

This is actually a prerequisite for the next goal, replay database. We want an efficient way to track a bunch of folders for changes, and update our replay database with the SLP file data. This indexing process can be potentially quite resource intensive and so we need a way to enable/disable the file indexing (and database updating) during games (check for Dolphin.exe running). Using Axosoft/nsfw (which seems like it would be faster than chokidar) inside of a node worker may be a good start.

Replay database

We didn't get around to adding this feature with version 2. With version 3 it would be nice to have finally add a replay database containing the game start block and metadata block, in a relational database. We can then add custom filters for finding games based off character or stage, player names, etc. We might potentially want to also expose endpoints for 3rd party applications to query the database.

Relay 2.0

We currently have the ability to expose live Slippi game data over a local server for 3rd party applications to tap into, also called the Console Relay. With Relay 2.0 we should be able to expose this data via WebRTC to allow applications over the web to be able to receive the game data feed. We may want to create some sort of permissioned system to allow websites to request access to the live game data, with some sort of prompt that shows up in the launcher. Using WebRTC will allow us to reduce the load on the Electron main thread since we don't have to actively maintain a websocket server.

Add an option to group contiguous replays based on the player names. Ideally we would have some form of multi replay stats support when this gets implemented

I have node 12 installed in my machine, and I am not able to build. This happens because when using node 12 the it is not possible to install/build node-sass 4.10.0.

node-sass needs to be upgrade to at least 4.12.x Keep in mind node 12 is the latest LTS version.

After #62, the scroll position on the page is no longer restored after returning back to the replay browser from a game replay. This is because scroll position is restored in ‘componentDidMount’, which occurs before the game rows are rendered.

Users have to wait about 2 seconds every time they launch the app just for both Dolphins to be checked for updates, but updates are not very frequent. We should move the update check to the background and give users a notification telling them that there is an update available. Updates should happen on click of the notification or when the app is next launched.

One of the features that hasn't been ported over in refactor/rewrite is the ability to multiselect replay files to play/delete. We should add back in the ability to multiselect files by clicking on them (i.e. without an explicit checkbox like in the current desktop app). A similar toolbar at the bottom with play all, clear, delete should show up when files are selected.

Adding L-Cancels to the stats page was not easy and showed that the stats page was in need of a refactor. Code design should be discussed with Vince and I.

Are there any plans for a Slippi Desktop API? If not I'd take a crack at it.

Goal

Something similar to the ballchasing.com API for Rocket League, specifically the /replays endpoint. Would allow users to query their replays for specific data.

• Would make it much easier for other people to generate stats or build other tools off of Slippi, and is much more user-friendly than the existing method of parsing one replay at a time (using a slp parsing library.)
• Possibly faster(?)

In the file below, the falco dies off of a grab release on his third stock. The punish stat for this interaction lacks any moves so the kills table fails to generate and breaks the entire stats page.

Game_20191008T211638.zip

With Desktop App v1.6.8, Developer mode no longer works in replays, even if the gecko code is enabled. This prevents users from pausing, turning the camera, showing hitboxes, etc. and is a regression from v1.6.7.

This has been brought up in the Discord a few times, but I am opening an issue to help track that it still needs to be fixed.

Commonly updated settings should be updatable via the Launcher's dolphin settings page. These should not be editable when Dolphin is open because it wouldn't know the changes were made and overwrite them on close. This issue does not cover gecko codes (#177).

Repro steps:

1. Go to browse replays in a root folder that has replays in it
2. Browse in file explorer to the replays currently loaded
3. Rename one of the files
4. Click back in desktop app
5. Go back into browse replays, the app should crash with errors that it can't read from a file with the old name

Some people might want to store replays in multiple folders across multiple drives.

• Netplay Replay Folder must always exist and be a valid path.
• Ability to add and delete additional replay folders
• Replays folders must show up in the replays tab

When the user hasn't yet selected whether a Console connection "is realtime" yet or not, the value is null. So when it gets serialized into ubjson and sent to console, the ubjson looks like this: (just a partial look)

0x69, 0x0a, 0x69, 0x73, 0x52, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x4e

That last 0x4e (N) is a ubjson "Null operation" and has no value. So the whole message becomes invalid to parse.

Basically, the app should default "isRealtime" to false, rather than leaving it null when unchosen.
https://github.com/project-slippi/slippi-desktop-app/blob/a8e783cab96cf51831850c092b848c323005e854/app/domain/ConsoleCommunication.js#L74

Lots of users are getting confused when they open up their replay browser and just see a bunch of Unknown time replays that aren't recent. While we have fixed the issue on the asm side, the browser will still be heavily populated with these replays for many users.

I'm leaving the issue kinda vague cause I want to see what people can come up with. Hiding or just straight up deletion is fine, but they should be optional. Maybe do both?

Right now people have to launch a configure dolphin or update their ISO to use UnclePunch Training Mode or 20XX. A way to launch dolphin from the home page without starting an ISO would suffice. A possibly more cohesive option would be to let the user add a Training ISO and have a way to start that specific ISO.

The path to the AppImage file in the Exec field of the desktop file is wrapped in quotes, which causes errors such as the following when using xdg-open:
which: no Slippi-Launcher-1.4.4-x86_64.AppImage" in (./"/home/haystack/source)

This makes it so you cannot open .slp files from the Slippi site in your browser because the URL handling is done by xdg as well. Opening opening a .slp file from a file browser will also most likely be broken by this although it may depend on your file browser.

If I manually remove the quotes in the Exec field of the desktop file, then it works fine and the slippi:// URLs are handled properly and I can open the files directly with xdg-open as well.

The spec seems to imply that it should be fine to double quote the path, so I'm not entirely sure why it doesn't work. Could possibly be an upstream bug in xdg-utils.

Arguments may be quoted in whole. If an argument contains a reserved character the argument must be quoted. The rules for quoting of arguments is also applicable to the executable name or path of the executable program as provided.

For debugging purposes, here's the generated desktop file (~/.local/share/applications/appimagekit-slippi-desktop-app.desktop):

[Desktop Entry]
Name=Slippi Launcher
Comment=Slippi Desktop App for browsing and playing replays.
Exec=/home/haystack/source/Slippi-Launcher-1.4.4-x86_64.AppImage %U
Terminal=false
Type=Application
Icon=appimagekit-slippi-desktop-app
StartupWMClass=Slippi Launcher
X-AppImage-Version=1.4.4
MimeType=x-scheme-handler/slippi;
Categories=Development;
X-AppImage-BuildId=1K1bOeuJzPhoG9WcseHboZyGhZK
X-Desktop-File-Install-Version=0.24
X-AppImage-Comment=Generated by /tmp/.mount_SlippipSpjHL/AppRun
TryExec=/home/haystack/source/Slippi-Launcher-1.4.4-x86_64.AppImage

The number of replays with Unknown time has been increasing recently and it might be worth just inferring the time from the file name if the metadata is empty since most users are probably not going to rename the files. If the time can't be inferred then it will stay as Unknown.

Time format for replay names is %Y%m%dT%H%M%S on Dolphin.
For Nintendont, check this: https://github.com/project-slippi/Nintendont/blob/slippi/kernel/SlippiFileWriter.c#L83-L87 (we write the MAC address in addition to the timestamp)

The desktop app is long overdue for a rewrite. This issue is just so we can keep track of the overall work to be done. Work is being done in https://github.com/project-slippi/slippi-desktop-app/tree/refactor/rewrite and rewrite/* branches. Always make a branch off of refactor/rewrite with the name rewrite/<feature name>.

The rewrite is now open to outside contributions. However I suggest you discuss code design with me and Vince before implementing something so you don't waste time on something we don't like.

Deferred for now

• Gecko code disabling (Nikki)
• Replay caching (#126)
• Global Stats (#125)
• Replay grouping
  • Like this
• Friends list
  • Should be able to add friends manually or from the replay browser.
  • Should let you invite friends to play some games (no chat though).
  • Will likely require Fizzi supervision.
• Visualizer
• Show patch notes after an update (#132)
• Multiple top level folders (#131)
• Install GCC Adapter drivers on install of desktop app or with the click of a button
  • I don't want this merged in until after the first release of the new desktop app. The issue is that i have no clue if antivirus software programs will complain about what it is doing.
  • To do this all you need to do is run the simple installer found here: https://github.com/project-slippi/libwdi/releases/tag/slippi-v1

Done

• Logging in with slippi.gg credentials
• Big Medium play button
• Downloading the latest netplay dolphin
• Launching netplay Dolphin
• Replay browser (#117)
• Game Profile (#115)
• Download latest playback dolphin (#120)
• Auto update dolphin by comparing version with release (#120)
• DolphinManager (#121)
  • manages all instances of dolphin (netplay, playback, spectate, config) and launches them from the main thread
• Download dolphin on main thread (#124)
• News feed (#129)
• Dolphin Settings page (#130)
• Console/Broadcasting (rewrite/broadcast-spectator branch) (#148)
  • basic notes: https://imgur.com/a/QVGQpEq
• Prompt for local play when not logged in
• Finish updating styles to match designs
• New icon designs
• Prompt and quick start page for when user hasn't created online connect code
• Console mirroring and autoswitcher (rewrite/mirroring)
• merge master changes like v6 of slippi-js, new stats etc.
• Test playback + netplay dolphin installing and auto-updating on all platforms
• QA testing on mac and linux
• SLP file association
• Electron app auto-updating

Drag and drop is a useful feature for sharing replays, but having to do them one at a time might not be ideal so there should be some way to drag and drop all the selected files on the replay browser.

Being able to easily add accounts to/remove accounts from the slippi desktop and switch to an account with a couple of clicks would be pretty sick imo.

This action should trigger a full refresh.

You can repro by accessing the browser, adding a new file to the folder, pressing back, and returning to the browser. The new file will not be there

Long load times are unfortunately not isolated to the startup of the desktop app - Upon returning back to the replay browser from a game stat screen, replays are reloaded from disk.

Consider adding application-level caching to previously loaded games.

Relies on #178

Some basic options would include stage and characters. Complex filtering should be closer to writing SQL queries but with a bit less complexity.

The app just updates automatically and without notice to the user right now. Adding a notification and the ability to choose when to update would help reduce confusion about if an update worked or not. There could also be a setting that enables or disables always updating on close.

Patch notes are already listed in the news section (#129), but adding a modal to bring the notes front and center after an update is still important so that people don't accidentally miss what changed in an update.

• Display a modal that has all the patch notes for each update
  • This may require showing multiple modals or combining the patch notes.

When fetching the list of broadcasts it currently returns the following type:

{
  broadcaster: {
    name: string;
    uid: string;
  };
  id: string;
  name: string;
}

However, the id field is identical to broadcaster.uid. This means it's not possible for a single user to broadcast multiple streams.

There may be a use case where people might want to broadcast say a Dolphin instance, and a console mirror, or multiple consoles etc. One example I can think of is say primary streams and secondary streams on Twitch.

If we want to support such a use case, backend server changes are required, since it's the server which determines a broadcast ID.

As of the latest pull request (#58 ), sub directories do not filter anything. The store's list of files updates, but filesToRender does not.

Components should not have to deal with handling IPC calls directly. IPC calls should be encapsulated inside of an async function inside of lib which components can then import.

It may also be helpful to have the functions exported inside of a hook so that the exported function already handles errors using addToast.

The last one went so well!

Right now the scroll position is updated when the FileLoader component is updated, but it doesn't scroll to the correct spot.

Test:

1. Ensure the folder has enough replays to require lazy loading
2. Scroll to the very bottom (load all replays)
3. View stats of any replay at the bottom
4. Press Back to return to the replay browser
5. Confirm that the replay browser did not scroll to the bottom.

I'm getting the error:

Command failed: /Users/axlui/Library/Application Support/Slippi Desktop App/dolphin/Slippi Dolphin.app/Contents/MacOS/Slippi Dolphin -i /var/folders/y5/r8b115js4wd2pzx8r9bnp4qc0000gn/T/slippi-comm-vod-6af709a95845c07cf90f6ca7.txt -b -e /Users/axlui/SMASHH/Super Smash Bros. Melee (USA) (v1.02) copy.iso

when trying to stream .slp files from the new client. I'm not sure how I can gain more visibility into what is going on.

Currently, there's no support for the pagination/segmentation of replays. The result of this is that every replay file must be loaded before the UI becomes usable.

After using slippi for a few months (accumulating about 2500 replays), my load time is about 15-20 seconds. Adding proper pagination support would allow for a constant load time of the desktop app.

Discussion/comments about the design should be done here for posterity.

Will reopen when we feel the design is in a good spot to be critiqued.

There have been a number of reports in the discord. We need to do some investigation and probably implement node workers to handle mirroring, broadcasting, and spectating.

This isn't exactly a bug, but it would be really helpful if you chould choose the install location of Project Slippi rather than just having it default to the C drive. My C drive is essentially full, so I'd rather not put more programs on to it.

Description

Add a database that caches replay data so we don't have to parse replay files all the time. Currently the work being done in this space can be seen in #400. It addresses most of the issues raised with previous implementation attempts, such as:

• Database interactions do not block main, since they run in a worker
• Migrations are automatically handled by the kysely package
• We have typed databases and typed database interactions thanks to the kysely package
• It's fairly well tested

Roll-out plan, and future improvements

1. Merge #400
2. Once well tested, remove the old FileSystemReplayProvider
3. Add pagination and continuation support such that we don't return all replays in a folder
4. Remove virtualization in the replay browser
5. Add search/sort/filter capabilities by utilising the database
6. [Stretch] Add match/set/session groupings

Right now the browser always filters games shorter than 30sec. This value ought be modifiable. Perhaps something interesting happened during a quick handwarmer.
I tried implementing it myself, but I have no idea how react works, to be honest.
kleutzinger-forks@5867ec5
the form to modify the value is mostly nonfuctional/wrong, but other two files are probably close.

Friends list should be part of the user's data on the website so this will require some supervision from Fizzi.

Add friends manually or from the replay browser. Website backend should provide desktop app with list of friends. friend requests, and declined friend requests. Friend requests should be accepted or declined. Declined friend should not be able to re-request unless the user clears the decline.

Some method of communication might be fine, to say invite a friend to play some games. It would be nice to have discord integration at this point so that users can share their discord with added friends.

I noticed a very weird interaction where if you open two dolphins for configuring, the close event of the dolphin opened second won't trigger until you close the dolphin you opened first. This doesn't happen when you launch netplay and a replay.

Steps to repro:

1. Add some log statements in the close events for configuration dolphins.
2. Configure a Netplay Dolphin.
3. Configure a Playback Dolphin.
4. Close Playback Dolphin, notice that the log message doesn't show up.
5. Close Netplay dolphin, notice that the log message for netplay shows up immediately and then the log message for playback shows up.

Currently the website lists version 1.6.4 as the latest and provides downloads for this version, but version 1.6.5 seems to already be out.

Also would there be a possibility to open-source the website itself, or at least a way to provide feedback about it?

My friends say "Dolphin in Slippi desktop app cannot load slp files, it always say 'waiting for game..'" to me.

We're Japanese, so their username of Windows is "full-width" Japanese character (for example "安井").
They tried downloading slp file to the path including only "half-width" character, then the slp file could be loaded.

The desktop app is now capable of launching dolphin for playback and netplay, but modifying dolphin requires going to the folder in appdata which isn't convenient. We have settings pages available which we can populate with various dolphin settings. There should be a page for Netplay Dolphin Settings and Playback Dolphin Settings, but most of the options will be the same.

Bolded items are required for this issue to be closed.

• Configure button
• Reset button
• Clear Cache button
• Modify simple settings
  • ex: ability to turn on and off gecko codes

Image Image2

The custom replay root directory is not functioning as intended, files are being sent to User\Documents\Slippi despite having custom directory set. The same custom directory worked in a previous version (not sure which).

I just downloaded the latest Slippi Desktop app for Linux from slippi.gg, version 1.4.5.
When firing up the app, it looks like it just gets the latest release off of Github and expects to see a latest-linux.yml.
The latest release on Github is 1.5.1, but that was not built/released for linux, and there is no latest-linux.yml.

This is my first time trying the app so I don't know if what I then observed is relevant:

• Configuring paths went fine
• Could launch FM dolphin by clicking "Configure Dolphin". It says "Waiting for game"
• After configuring paths, I clicked the "Back button", but the app still says "Root Folder Missing".

App logs:

$ ./Slippi-Launcher-1.4.5-x86_64.AppImage                                                                                                                                                                       
[19:10:34.122] [info] App starting...
[19:10:34.326] [info] Handling URL...
[19:10:34.326] [info] 
[19:10:34.327] [info] protocol: null:, hostname: null
[19:10:35.544] [info] Checking for update
[19:10:36.808] [error] Error: Error: Cannot find latest-linux.yml in the latest release artifacts (https://github.com/project-slippi/slippi-desktop-app/releases/download/v1.5.1/latest-linux.yml): HttpError: 404 Not Found
"method: undefined url: https://github.com/project-slippi/slippi-desktop-app/releases/download/v1.5.1/latest-linux.yml\n\nPlease double check that your authentication token is correct. Due to security reasons actual status maybe not reported, but 404.\n"

After those startup logs, a dump of the request headers and a stack trace follows.

Have a button that downloads, if necessary, and installs the right driver for GC adapters depending on the OS.

• Windows
  • https://github.com/project-slippi/libwdi/releases/download/slippi-v1/slippi-simple-gc-driver.exe (requires elevated perms) Handled in #210.
• macOS
  • Not doable at the moment Link https://github.com/secretkeysio/GCAdapterDriver/releases/latest
• Linux
  • Maybe just show the command they have to run, Linux users should be able to get their way around.

  sudo rm -f /etc/udev/rules.d/51-gcadapter.rules && sudo touch /etc/udev/rules.d/51-gcadapter.rules && echo 'SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="0337", MODE="0666"' | sudo tee /etc/udev/rules.d/51-gcadapter.rules > /dev/null && sudo udevadm control --reload-rules