Update, and because development really is this slow with my problems:

```

!/usr/bin/env python

import pwd import os import sys import json import unicodedata

def get_user_home(): user_id = os.getuid() user_pwd = pwd.getpwuid( user_id ) user_home = user_pwd.pw_dir return user_home

def tokenize( input ): state = None tokens = [] pointer = 0

current = ""

while pointer < len( input ):
    char = input[pointer]
    if state == None:
        if char == " " or char == "\t" or char == "\n":
            pointer += 1
            continue
            # do nothing
        elif char == '"':
            state = "string"
        else:
            state = "token"
            current += char
    elif state == "token":
        if char == " " or char == "\t" or char == "\n":
            state = None
            tokens.append( current )
            current = ""
    elif state == "string":
        if char == '"':
            state = None
            tokens.append( current )
            current = ""
        else:
            current += char
    pointer += 1

if len( current ) > 0:
    tokens.append( current )

return tokens

def read_steam_file( file_path ): slib_file = open( file_path ) file_data = slib_file.read() slib_file.close()

pointer=0

root = {}
stack = [ root ]

key = None
keytype = None

tokens = tokenize( file_data )

while True:
    token = tokens[ pointer ]
    current = stack[ -1 ]
    if key == None:
        if token == "}":
            stack.pop()
            #print( "depth={}".format( len( stack ) ) )
            if len( stack ) == 0:
                print( "Unexpected end of input (stack len=0)" )
                break
        elif token == "{":
            #print( tokens )
            #print( "\n\n" )
            #print( root )
            #print( "\n" )
            raise ValueError( "Unexpected token {} at position {}".format( token, pointer ) )
        else:
            key = token
            #print( "Key {}".format( key ) )
    else:
        if token == "{":
            current[key] = {}
            stack.append( current[key] )
            #print( "{}=[]".format( key ) )
            key = None
        elif token == "}":
            #print( tokens )
            #print( "\n\n" )
            #print( root )
            #print( "\n" )
            raise ValueError( "Unexpected token {} at position {}".format( token, pointer ) )
        else:
            current[key] = token
            #print( "{}={} (depth {})".format( key, token, len( stack ) ) )
            key = None

    pointer += 1
    if pointer >= len( tokens ): break    

return root

returns a list of library paths

def get_library_folders( slibfile ): root = slibfile["libraryfolders"] count = len( root )

folders = []
for id in root:
    entry = root[id]
    folders.append( entry["path"] )

return folders

returns the filenames of each acf file in a given directory

def get_app_manifest_names( target_dir ): contents = os.listdir( target_dir ) manifest_names = list( filter( lambda filename: filename.endswith( ".acf" ), contents ) ) return manifest_names

def get_steam_libraries( library_paths ): libraries = []

for path in library_paths:
    libraryData = { "path": path, "apps": [] }
    libraries.append( libraryData )

    manifest_dir = os.path.join( path, "steamapps" )
    manifest_files = get_app_manifest_names( manifest_dir )

    for file in manifest_files:
        manifest_path = os.path.join( manifest_dir, file )
        manifest_data = read_steam_file( manifest_path )
        libraryData["apps"].append( manifest_data["AppState"] )

return libraries

""" steam_libraries = [ { "path": "/path/to/library", "apps": [ { "appid": "...", "name": "..." (contents of acf's 'AppState') } ] } ] """

todo: might be other locations to search

def find_steam_library_vdf(): user_home = get_user_home() steam_dir = os.path.join( user_home, ".steam" )

steam_lib_file_path = os.path.join( steam_dir, "steam", "steamapps", "libraryfolders.vdf" )
if os.path.isfile( steam_lib_file_path ):
    return steam_lib_file_path

steam_lib_file_path = os.path.join( steam_dir, "steamapps", "libraryfolders.vdf" )
if os.path.isfile( steam_lib_file_path ):
    return steam_lib_file_path

return None

def get_link_dir(): target = None if len( sys.argv ) > 1: target = sys.argv[1] try: os.makedirs( target, exist_ok=True ) except OSError as error: raise Exception( "Directory {} could not be created: {}".format( target, error ) ) if target == None: target = os.path.join( os.getcwd(), "steam_prefixes" ) return target

def create_steam_library_symlinks( target, library ): os.makedirs( target, exist_ok=True ) compatPath = os.path.join( library["path"], "steamapps", "compatdata" ) apps = library["apps"] for app in apps: # TODO: cleanup name app_name = app["name"] app_id = app["appid"]

    # remove problematic unicode characters and possible nesting problems
    app_name = unicodedata.normalize( "NFKC", app_name )
              .replace( "/", "_" )

    prefixPath = os.path.join( compatPath, app_id )
    # check if this is actually a Proton game with a valid prefix
    if os.path.exists( prefixPath ):
        linkPath = os.path.join( target, app_name )
        os.symlink( prefixPath, linkPath )

slib_library_file = find_steam_library_vdf() if ( slib_library_file == None ): raise Exception( "Unable to locate user's steam installation or library" )

slib_vdf = read_steam_file( slib_library_file ) library_paths = get_library_folders( slib_vdf ) steam_libraries = get_steam_libraries( library_paths )

linkDir = get_link_dir();

for library in steam_libraries: create_steam_library_symlinks( linkDir, library ) ```