diff --git a/images/platform-icons/bilibili.png b/images/platform-icons/bilibili.png
new file mode 100644
index 0000000..3162d26
Binary files /dev/null and b/images/platform-icons/bilibili.png differ
diff --git a/manifest.json b/manifest.json
index c1d4638..532d4a4 100644
--- a/manifest.json
+++ b/manifest.json
@@ -38,6 +38,8 @@
       "inc/he.js",
       "js/lib.js",
       "js/zs-background.js",
+      "modules/bilibili_pinia_parser.js",
+      "modules/bilibili.js",
       "modules/tiktok.js",
       "modules/tiktok-comments.js",
       "modules/instagram.js",
diff --git a/modules/bilibili.js b/modules/bilibili.js
new file mode 100644
index 0000000..e7cec42
--- /dev/null
+++ b/modules/bilibili.js
@@ -0,0 +1,104 @@
+zeeschuimer.register_module(
+    'Bilibili',
+    'bilibili.com',
+    function (response, source_platform_url, source_url) {
+        // Ensure each item has an "id" field using the bvid
+        function ensureItemId(item) {
+            if (item.bvid) {
+                item.id = item.bvid;
+            }
+            return item;
+        }
+
+        let domain = source_platform_url.split("/")[2].toLowerCase().replace(/^www\./, '');
+        if (!["bilibili.com"].includes(domain)) {
+            return [];
+        }
+
+        if (!response) {
+            return [];
+        }
+
+        let found_items;
+        let type_of_item;
+
+        // Try to parse as JSON first (API responses)
+        let data;
+        try {
+            data = JSON.parse(response);
+        } catch (SyntaxError) {
+            // Not JSON - might be HTML with embedded __pinia data
+            if (typeof response === 'string' && response.includes('window.__pinia')) {
+                console.log('Bilibili module: Detected HTML with __pinia, attempting to parse');
+                
+                // Extract the script tag or line containing window.__pinia
+                // Look for the line - it should be in a <script> tag
+                const lines = response.split('\n');
+                let piniaLine = '';
+                for (let line of lines) {
+                    if (line.includes('window.__pinia')) {
+                        piniaLine = line;
+                        break;
+                    }
+                }
+                
+                if (piniaLine) {
+                    // Parse the pinia data using the embedded parser
+                    const videos = parsePiniaData(piniaLine);
+                    
+                    if (videos && videos.length > 0) {
+                        console.log(`Bilibili module found ${videos.length} videos from __pinia HTML`);
+                        for (let i = 0; i < videos.length; i++) {
+                            console.log(`${i + 1}: ${videos[i].title || 'No title'}`);
+                        }
+                        return videos.map(ensureItemId);
+                    }
+                }
+            }
+            return [];
+        }
+
+        if (typeof data !== 'object' || !("data" in data) || typeof data["data"] !== 'object' ) {
+            return [];
+        // some Bilibili API responses use "item", some "archives"
+        }  else if (("item" in data["data"]) && Array.isArray(data["data"]["item"])) {
+            // Main display items array 
+            type_of_item = "main item array";
+            found_items = data["data"]["item"];
+        } else if (("archives" in data["data"]) && Array.isArray(data["data"]["archives"])) {
+            // Main display items array; on channel pages
+            type_of_item = "main archives array";
+            found_items = data["data"]["archives"];
+        } else if (("items" in data["data"]) && Array.isArray(data["data"]["items"])) {
+            // "Hot" cards that are added to the main display items array
+            // It appears that only one is used from the array, but not always the first...
+            type_of_item = "hot item array";
+            found_items = data["data"]["items"];
+        } else if (("recommend_room_list" in data["data"]) && Array.isArray(data["data"]["recommend_room_list"])) {
+            // Live room recommendations added to the main display items array
+            // Also appears that only one item in the array is used, but randomly
+            type_of_item = "recommend room list array";
+            found_items = [];
+            for (let item of data["data"]["recommend_room_list"]) {
+                item["id"] = item["roomid"];
+                found_items.push(item);
+            }
+        } else {
+            // No recognized items found
+            return [];
+        }
+        console.log(`Bilibili module found (${type_of_item}) items in ${source_url}:`);
+
+        i = 0;
+        for (let item of found_items) {
+            i++;
+            if (typeof item == 'object' || ('title' in item)) {
+                console.log(`${i}: ${item['title']}`);
+            } else {
+                console.log(`Invalid item ${i}  in ${type_of_item}:`);
+                console.log(item);
+            }
+        }
+        return found_items.map(ensureItemId);
+    }
+);
\ No newline at end of file
diff --git a/modules/bilibili_pinia_parser.js b/modules/bilibili_pinia_parser.js
new file mode 100644
index 0000000..18fbd8f
--- /dev/null
+++ b/modules/bilibili_pinia_parser.js
@@ -0,0 +1,398 @@
+/**
+ * Robust parser for Bilibili's __pinia obfuscated data
+ * Extracts video data by parsing the function body and mapping parameters to values
+ * This approach is resilient to parameter name changes and position shifts
+ */
+
+function parsePiniaData(htmlContent) {
+    console.log('Starting robust pinia parser');
+    console.log('HTML content length:', htmlContent.length);
+    
+    // 1. Extract the entire function by finding window.__pinia and parsing with brace/paren counting
+    const piniaIndex = htmlContent.indexOf('window.__pinia');
+    if (piniaIndex === -1) {
+        console.log('Could not find window.__pinia in content');
+        return [];
+    }
+    
+    // Find the opening ( after the =
+    const eqIndex = htmlContent.indexOf('=', piniaIndex);
+    let startIndex = eqIndex + 1;
+    while (startIndex < htmlContent.length && /\s/.test(htmlContent[startIndex])) {
+        startIndex++;
+    }
+    
+    if (htmlContent[startIndex] !== '(') {
+        console.log('Expected ( after window.__pinia=');
+        return [];
+    }
+    
+    // Extract the IIFE: (function(...){...})(...)
+    // We need to find where the outer parens close
+    let parenDepth = 0;
+    let endIndex = startIndex;
+    for (let i = startIndex; i < htmlContent.length; i++) {
+        if (htmlContent[i] === '(') parenDepth++;
+        if (htmlContent[i] === ')') {
+            parenDepth--;
+            if (parenDepth === 0) {
+                endIndex = i;
+                break;
+            }
+        }
+    }
+    
+    const fullIIFE = htmlContent.substring(startIndex + 1, endIndex); // Remove outer parens
+    console.log('Extracted IIFE, length:', fullIIFE.length);
+    
+    // Now we have: function(...){...})(...)
+    // Find where "function" starts
+    const functionKeywordIndex = fullIIFE.indexOf('function');
+    if (functionKeywordIndex === -1) {
+        console.log('Could not find function keyword');
+        return [];
+    }
+    
+    // Find the opening ( for parameters
+    const paramStartIndex = fullIIFE.indexOf('(', functionKeywordIndex);
+    let paramEndIndex = paramStartIndex;
+    parenDepth = 0;
+    for (let i = paramStartIndex; i < fullIIFE.length; i++) {
+        if (fullIIFE[i] === '(') parenDepth++;
+        if (fullIIFE[i] === ')') {
+            parenDepth--;
+            if (parenDepth === 0) {
+                paramEndIndex = i;
+                break;
+            }
+        }
+    }
+    
+    const paramNamesStr = fullIIFE.substring(paramStartIndex + 1, paramEndIndex);
+    
+    // Find the function body { ... }
+    const bodyStartIndex = fullIIFE.indexOf('{', paramEndIndex);
+    let bodyEndIndex = bodyStartIndex;
+    let braceDepth = 0;
+    for (let i = bodyStartIndex; i < fullIIFE.length; i++) {
+        if (fullIIFE[i] === '{') braceDepth++;
+        if (fullIIFE[i] === '}') {
+            braceDepth--;
+            if (braceDepth === 0) {
+                bodyEndIndex = i;
+                break;
+            }
+        }
+    }
+    
+    const functionBody = fullIIFE.substring(bodyStartIndex + 1, bodyEndIndex);
+    
+    // Find the arguments: everything after })(...)
+    const argsStartIndex = fullIIFE.indexOf('(', bodyEndIndex);
+    const argsString = fullIIFE.substring(argsStartIndex + 1).trim();
+    
+    console.log('Extracted parameters, body, and arguments successfully');
+    
+    // 2. Parse parameter names
+    const paramNames = paramNamesStr.split(',').map(p => p.trim()).filter(p => p);
+    console.log(`Found ${paramNames.length} parameter names`);
+    
+    // 3. Parse argument values
+    const args = parseArguments(argsString);
+    console.log(`Parsed ${args.length} argument values`);
+    
+    if (paramNames.length !== args.length) {
+        console.warn(`Parameter count (${paramNames.length}) doesn't match argument count (${args.length})`);
+    }
+    
+    // 4. Create parameter -> value mapping
+    const paramMap = {};
+    paramNames.forEach((param, index) => {
+        if (index < args.length) {
+            paramMap[param] = args[index];
+        }
+    });
+    
+    console.log(`Created parameter map with ${Object.keys(paramMap).length} entries`);
+    
+    // 5. Extract video objects from the function body
+    const videos = extractVideosFromFunctionBody(functionBody, paramMap);
+    
+    console.log(`Successfully extracted ${videos.length} videos`);
+    return videos;
+}
+
+function parseArguments(argsString) {
+    const args = [];
+    let current = '';
+    let inString = false;
+    let stringChar = null;
+    let depth = 0;
+    let escaping = false;
+    
+    for (let i = 0; i < argsString.length; i++) {
+        const char = argsString[i];
+        
+        if (escaping) {
+            current += char;
+            escaping = false;
+            continue;
+        }
+        
+        if (char === '\\') {
+            escaping = true;
+            current += char;
+            continue;
+        }
+        
+        if ((char === '"' || char === "'") && !escaping) {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+                current += char;
+            } else if (char === stringChar) {
+                inString = false;
+                stringChar = null;
+                current += char;
+            } else {
+                current += char;
+            }
+            continue;
+        }
+        
+        if (inString) {
+            current += char;
+            continue;
+        }
+        
+        if (char === '{' || char === '[') {
+            depth++;
+            current += char;
+        } else if (char === '}' || char === ']') {
+            depth--;
+            current += char;
+        } else if (char === ',' && depth === 0) {
+            const value = parseValue(current.trim());
+            args.push(value);
+            current = '';
+        } else {
+            current += char;
+        }
+    }
+    
+    if (current.trim()) {
+        args.push(parseValue(current.trim()));
+    }
+    
+    return args;
+}
+
+function parseValue(str) {
+    if (!str) return null;
+    
+    if (str === 'null') return null;
+    if (str === 'undefined') return undefined;
+    if (str === 'true') return true;
+    if (str === 'false') return false;
+    if (str === 'void 0') return undefined;
+    
+    // Handle quoted strings
+    if ((str.startsWith('"') && str.endsWith('"')) || 
+        (str.startsWith("'") && str.endsWith("'"))) {
+        let unquoted = str.slice(1, -1);
+        
+        // Handle escape sequences
+        unquoted = unquoted
+            .replace(/\\"/g, '"')
+            .replace(/\\'/g, "'")
+            .replace(/\\n/g, '\n')
+            .replace(/\\t/g, '\t')
+            .replace(/\\r/g, '\r')
+            .replace(/\\\\/g, '\\')
+            .replace(/\\u([0-9a-fA-F]{4})/g, (match, hex) => {
+                return String.fromCharCode(parseInt(hex, 16));
+            })
+            .replace(/\\x([0-9a-fA-F]{2})/g, (match, hex) => {
+                return String.fromCharCode(parseInt(hex, 16));
+            });
+        
+        return unquoted;
+    }
+    
+    // Handle numbers
+    if (/^-?\d+$/.test(str)) {
+        return parseInt(str, 10);
+    }
+    
+    if (/^-?\d+\.\d+$/.test(str)) {
+        return parseFloat(str);
+    }
+    
+    // Handle objects/arrays (though we mostly won't see these in args)
+    if (str.startsWith('{') || str.startsWith('[')) {
+        try {
+            return JSON.parse(str);
+        } catch (e) {
+            return str;
+        }
+    }
+    
+    return str;
+}
+
+function extractVideosFromFunctionBody(functionBody, paramMap) {
+    const videos = [];
+    
+    // Find the recommend.item array in the function body
+    // Pattern: recommend:{item:[{...},{...},...],
+    const itemArrayPattern = /recommend:\s*\{\s*item:\s*\[([\s\S]*?)\],\s*business_card:/;
+    const itemMatch = functionBody.match(itemArrayPattern);
+    
+    if (!itemMatch) {
+        console.log('Could not find recommend.item array in function body');
+        return [];
+    }
+    
+    const itemsString = itemMatch[1];
+    console.log('Found items array, length:', itemsString.length);
+    
+    // Extract individual video object definitions
+    const videoObjects = extractObjectDefinitions(itemsString);
+    console.log(`Found ${videoObjects.length} video object definitions`);
+    
+    // Parse each video object
+    for (let i = 0; i < videoObjects.length; i++) {
+        const objString = videoObjects[i];
+        const video = parseVideoObject(objString, paramMap, i);
+        
+        if (video) {
+            // Only include if it has a valid BVID (filter out ads or invalid entries)
+            if (video.bvid && typeof video.bvid === 'string' && video.bvid.startsWith('BV')) {
+                videos.push(video);
+            }
+        }
+    }
+    
+    return videos;
+}
+
+function extractObjectDefinitions(itemsString) {
+    const objects = [];
+    let depth = 0;
+    let start = -1;
+    
+    for (let i = 0; i < itemsString.length; i++) {
+        if (itemsString[i] === '{') {
+            if (depth === 0) start = i;
+            depth++;
+        } else if (itemsString[i] === '}') {
+            depth--;
+            if (depth === 0 && start >= 0) {
+                objects.push(itemsString.substring(start, i + 1));
+                start = -1;
+            }
+        }
+    }
+    
+    return objects;
+}
+
+function parseVideoObject(objString, paramMap, index) {
+    // Extract field mappings using regex patterns
+    // Pattern: fieldName:paramName
+    
+    const video = {
+        _zeeschuimer_metadata: {
+            type: 'pinia_embedded_items',
+            source: 'html_embedded_obfuscated',
+            likely_displayed: true,
+            position: index
+        }
+    };
+    
+    // Define patterns for fields we care about
+    const simpleFields = {
+        id: /\bid:(\w+)/,
+        bvid: /\bbvid:(\w+)/,
+        cid: /\bcid:(\w+)/,
+        goto: /\bgoto:(\w+)/,
+        uri: /\buri:(\w+)/,
+        pic: /\bpic:(\w+)(?!_)/,  // pic but not pic_4_3
+        pic_4_3: /\bpic_4_3:(\w+)/,
+        title: /\btitle:(\w+)/,
+        duration: /\bduration:(\w+)/,
+        pubdate: /\bpubdate:(\w+)/,
+        av_feature: /\bav_feature:(\w+)/,
+        is_followed: /\bis_followed:(\w+)/,
+        track_id: /\btrack_id:(\w+)/,
+        pos: /\bpos:(\w+)(?!_)/,
+    };
+    
+    // Extract simple fields
+    for (const [field, pattern] of Object.entries(simpleFields)) {
+        const match = objString.match(pattern);
+        if (match) {
+            const paramName = match[1];
+            const value = paramMap[paramName];
+            if (value !== undefined && value !== null) {
+                video[field] = value;
+            }
+        }
+    }
+    
+    // Extract owner object: owner:{mid:X,name:Y,face:Z}
+    const ownerPattern = /owner:\s*\{\s*mid:(\w+),\s*name:(\w+),\s*face:(\w+)\s*\}/;
+    const ownerMatch = objString.match(ownerPattern);
+    if (ownerMatch) {
+        video.owner = {
+            mid: paramMap[ownerMatch[1]],
+            name: paramMap[ownerMatch[2]],
+            face: paramMap[ownerMatch[3]]
+        };
+    }
+    
+    // Extract stat object: stat:{view:X,like:Y,danmaku:Z,vt:W}
+    const statPattern = /stat:\s*\{\s*view:(\w+),\s*like:(\w+),\s*danmaku:(\w+)/;
+    const statMatch = objString.match(statPattern);
+    if (statMatch) {
+        video.stat = {
+            view: paramMap[statMatch[1]],
+            like: paramMap[statMatch[2]],
+            danmaku: paramMap[statMatch[3]]
+        };
+    }
+    
+    // Extract rcmd_reason: rcmd_reason:{content:X,reason_type:Y} or rcmd_reason:{reason_type:Y}
+    const rcmdPattern = /rcmd_reason:\s*\{([^}]+)\}/;
+    const rcmdMatch = objString.match(rcmdPattern);
+    if (rcmdMatch) {
+        const rcmdContent = rcmdMatch[1];
+        const contentMatch = rcmdContent.match(/content:(\w+)/);
+        const reasonTypeMatch = rcmdContent.match(/reason_type:(\w+)/);
+        
+        video.rcmd_reason = {};
+        if (contentMatch) {
+            video.rcmd_reason.content = paramMap[contentMatch[1]];
+        }
+        if (reasonTypeMatch) {
+            video.rcmd_reason.reason_type = paramMap[reasonTypeMatch[1]];
+        }
+    }
+    
+    // Validate - must have at minimum id and bvid
+    if (!video.id || !video.bvid) {
+        console.log(`Skipping video at position ${index}: missing id or bvid`);
+        return null;
+    }
+    
+    console.log(`Parsed video ${index + 1}: ${video.bvid} - "${video.title || 'No title'}"`);
+    return video;
+}
+
+// Export for both Node.js (testing) and browser (extension) contexts
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = { parsePiniaData };
+} else {
+    // Browser context - expose globally
+    window.parsePiniaData = parsePiniaData;
+}