DCT
2:24-cv-00480
S3G Technology LLC v. Buffalo Wild Wings Inc
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: Buffalo Wild Wings, Inc. (Minnesota)
- Plaintiff’s Counsel: Parker, Bunt & Ainsworth, P.C.
- Case Identification: 2:24-cv-00480, E.D. Tex., 07/02/2024
- Venue Allegations: Plaintiff alleges venue is proper because Defendant maintains a regular and established place of business in the district, citing a specific restaurant address, and has committed acts of infringement within the district.
- Core Dispute: Plaintiff alleges that Defendant’s mobile applications and supporting server systems infringe three patents related to a method for efficiently modifying software on remote devices.
- Technical Context: The technology concerns a client-server architecture designed to update application features and user dialogues by sending small, lightweight data modules, avoiding the need to transmit and reinstall an entire software application.
- Key Procedural History: The complaint notes that terms from the asserted patent family were previously construed by the court in a prior case, S3G Tech. LLC v. Unikey Techs., Inc., which may influence claim construction in this matter. The complaint also references a Notice of Allowability for a related patent, arguing the examiner found the claimed structure to be novel and non-obvious over the prior art.
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Earliest Priority Date for ’897, ’124, and ’571 Patents |
| 2013-07-11 | ’571 Patent Family, Notice of Allowability Issued |
| 2013-10-29 | U.S. Patent No. 8,572,571 Issued |
| 2015-07-14 | U.S. Patent No. 9,081,897 Issued |
| 2017-07-07 | Court Construed Terms in S3G v. Unikey Techs., Inc. |
| 2018-04-10 | U.S. Patent No. 9,940,124 Issued |
| 2024-06-17 | Accused Android App Last Updated |
| 2024-06-19 | Accused iOS App Last Updated |
| 2024-07-02 | Complaint Filed |
II. Technology and Patent(s)-in-Suit Analysis
U.S. Patent No. 9,081,897 - “Modification of Terminal and Service Provider Machines Using an Update Server Machine,” Issued July 14, 2015
The Invention Explained
- Problem Addressed: The patent addresses the inefficiency of updating software applications distributed across many remote devices, particularly over wireless networks. Distributing a newly compiled version of an entire application can be difficult, time-consuming, and strain network bandwidth (Compl. ¶¶ 14-15; ’897 Patent, col. 2:18-56).
- The Patented Solution: The invention proposes a three-entity system architecture comprising an update server, a service provider machine, and a terminal machine. Instead of sending a full application update, the update server sends a small "dialogue module" containing "code"—defined as information that must be translated before it can be implemented by the processor. This module modifies the application's behavior (e.g., a sequence of user prompts) without altering the application's underlying, pre-existing "computer-executable instructions" (Compl. ¶¶ 16-17; ’897 Patent, col. 4:26-40). This architecture is illustrated in the complaint's reproduction of the patent's Figure 1 (Compl. ¶ 16).
- Technical Importance: This method of separating an application's static, executable instructions from its dynamic, updatable "code" aims to reduce network bandwidth consumption and increase the efficiency of modifying applications on remote devices (Compl. ¶ 25; ’897 Patent, col. 6:61-63).
Key Claims at a Glance
- The complaint asserts independent claim 1 (Compl. ¶ 32).
- Essential elements of Claim 1 (a system claim) include:
- An update server machine operable for sending a terminal dialogue module and a provider dialogue module.
- A terminal machine configured to run a terminal application.
- A service provider machine configured to run a provider application.
- The terminal and provider applications each comprise a set of computer-executable instructions and a set of code, where the instructions execute directly on a processor but the code does not.
- The dialogue modules modify their respective sets of code to produce updated code, adapting the application's dialogue sequence, without modifying the computer-executable instructions.
- The complaint alleges infringement of "one or more claims," reserving the right to assert others (Compl. ¶ 32).
U.S. Patent No. 9,940,124 - “Modification of Terminal and Service Provider Machines Using an Update Server Machine,” Issued April 10, 2018
The Invention Explained
- Problem Addressed: The technical problems are consistent with those described for the ’897 Patent, focusing on the challenges of updating remote software over bandwidth-constrained networks (Compl. ¶¶ 13-15).
- The Patented Solution: The ’124 patent claims a method for conducting a dialogue using the system architecture. The method involves displaying prompts, accepting user data, communicating that data to a service provider, storing it, and, crucially, receiving a "terminal dialogue module" that updates a portion of the application's "first code" to produce "first updated code." A key feature is the requirement that at least one of these codes comprises "intermediate code," such as bytecode that requires a virtual machine for interpretation (Compl. ¶¶ 52, 56; ’124 Patent, claim 1).
- Technical Importance: The method provides a specific process for dynamically altering an application's user-facing dialogue flow, aiming for the same efficiencies in network usage and update management as the ’897 Patent (Compl. ¶ 25).
Key Claims at a Glance
- The complaint asserts independent claim 1 (Compl. ¶ 50).
- Essential elements of Claim 1 (a method claim) include:
- Displaying a first prompt on a terminal machine using a terminal application comprising first computer-executable instructions and first code.
- Accepting a first data entry.
- Communicating information from the data entry to a service provider machine.
- Storing at least a portion of the information.
- Receiving, at the terminal machine, a terminal dialogue module that updates the first code to produce first updated code, which adapts the terminal application to display a second prompt.
- The requirement that at least one of the first code, second code (on the server), or first updated code comprises "intermediate code."
- The complaint alleges infringement of "one or more claims" (Compl. ¶ 50).
U.S. Patent No. 8,572,571 - “Modification of Terminal and Service Provider Machines Using an Update Server Machine,” Issued October 29, 2013
Technology Synopsis
The ’571 patent, part of the same family, also discloses a system for modifying remote software applications to solve the problem of distributing large, full application updates. The invention uses a three-entity architecture (update server, terminal, service provider) where small "dialogue modules" containing translatable "code" are sent to alter an application's dialogue sequence without replacing the core executable instructions (Compl. ¶¶ 16-17, 23).
Asserted Claims
The complaint asserts at least independent claim 2 (Compl. ¶ 70).
Accused Features
The complaint alleges that the Buffalo Wild Wings mobile app and server system infringes by using a three-entity structure to update features, such as a user's "favorite locations," by sending data (allegedly JSON) to the app, which modifies the user dialogue without replacing the entire application (Compl. ¶¶ 71-75).
III. The Accused Instrumentality
Product Identification
The accused instrumentalities are the Buffalo Wild Wings mobile applications for Android and iOS (the "Defendant app") and the associated back-end systems, computing devices, servers, and software that support them (the "Accused System") (Compl. ¶ 8).
Functionality and Market Context
- The Accused System allows users to interact with Defendant's services, with the complaint focusing on the "favorite location" feature as an exemplary infringing functionality (Compl. ¶ 13, fn. 8). This feature allows a user to engage in a dialogue of prompts and data entries to review, add, order from, or remove favorite restaurant locations (Compl. ¶¶ 35, 52). The complaint alleges that modifications to this dialogue (e.g., adding a new favorite location to a list) are achieved by sending data, such as a JSON file, from the Defendant's server to the user's device. This data is alleged to modify the application's behavior without requiring a full reinstallation of the app (Compl. ¶¶ 13, 56).
- The complaint alleges that Defendant derives a significant portion of its revenue from the promotion and distribution of its services through the Accused System (Compl. ¶ 8).
IV. Analysis of Infringement Allegations
Figure 1 from the complaint depicts the claimed three-entity computer system structure, including an update server machine, a service provider machine, and a terminal machine communicating wirelessly (Compl. ¶16). The infringement allegations map the Accused System onto this structure. Figure 2 from the complaint illustrates the specific structure of the applications, distinguishing between computer-executable instructions (224, 214) and translatable code (222, 212) on both the terminal and service provider machines (Compl. ¶17).
’897 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| an update server machine ... operable for sending a terminal dialogue module ... and a provider dialogue module... | The Defendant's server, or a user's device accessing the system, sends information (e.g., JSON data for a "favorite location") to the terminal machine (the app) and the service provider machine (the server). | ¶34 | col. 16:56-62 |
| a terminal machine ... configured to run a terminal application ... wherein the terminal application comprises a first set of computer executable instructions and a first set of code... | A user's Android smartphone running the Defendant app. The "computer executable instructions" are alleged to be the Android Runtime (ART), while the "code" is the app's bytecode, which is not directly executed by the processor. | ¶35 | col. 17:1-10 |
| a service provider machine ... configured to run a provider application ... wherein the provider application comprises a second set of computer-executable instructions and a second set of code... | The Defendant's server running a .Net server application. The "computer-executable instructions" are the .Net Common Language Runtime (CLR), while the "code" is the .Net program itself. | ¶36 | col. 17:11-23 |
| wherein the terminal dialogue module modifies the first set of code to produce a first set of updated code ... [and] adapts the terminal application to use a modified dialogue sequence... | Information sent from the server modifies the app's bytecode to produce updated code, which changes the user dialogue (e.g., adds a new favorite location to a list for selection). | ¶37 | col. 17:24-40 |
| wherein the terminal dialogue module does not modify the first set of computer-executable instructions... | The terminal dialogue module allegedly modifies the app's bytecode but not the underlying Android Runtime (ART), which comprises the computer-executable instructions. | ¶18 | col. 17:31-34 |
’124 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| displaying a first prompt on a terminal display of a terminal machine by running a terminal application... | The Defendant app prompts the user to review, order from, or remove favorite locations. | ¶52 | col. 16:19-24 |
| accepting a first data entry at the terminal machine... | The user selects an option, such as adding a new favorite location, via a button press or other input. | ¶53 | col. 16:25-29 |
| communicating information associated with the first data entry from the terminal machine to the service provider machine... | The user's selection is sent from the app on the user's device to the Defendant's server. | ¶54 | col. 16:30-38 |
| storing at least a portion of the information associated with the first data entry in memory for analysis. | The Defendant's server stores the new favorite location information so it can be recalled later. | ¶55 | col. 16:39-41 |
| receiving, at the terminal machine, a terminal dialogue module... that updates at least a portion of the first code to produce first updated code... | The app receives information (e.g., JSON) from the server that updates the app's bytecode (the "first code") to produce updated bytecode ("first updated code"). | ¶56 | col. 16:42-49 |
| wherein at least one of the first code, the second code, and the first updated code comprise intermediate code. | The complaint alleges that the app's bytecode constitutes "intermediate code." | ¶56 | col. 8:54-56 |
Identified Points of Contention
- Scope Questions: The core of the dispute may turn on whether structured data formats like JSON, as alleged by the Plaintiff, can be considered "code" and a "dialogue module" as those terms are used in the patents. The patents define "code" as "information that must be translated ... before it can be implemented on the machine processor," and a prior court construction noted it is "information that must be translated before it can be executed on a processor." A key question is whether parsing JSON data satisfies this definition.
- Technical Questions: The complaint's theory of infringement relies on a specific mapping: "computer-executable instructions" are equated to the runtime environment (Android's ART or Microsoft's .NET CLR), while "code" is equated to the application logic that runs on top of that environment (app bytecode or a .NET program). A central technical question will be whether this architectural separation in the accused products aligns with the distinction claimed in the patents.
V. Key Claim Terms for Construction
The Term: "code"
Context and Importance
This term is foundational to the patent's claimed invention, as it is the component that is modified by the "dialogue module." The outcome of the case may depend on whether the defendant's use of data formats like JSON to update its app content falls within the patent's definition of "code." Practitioners may focus on this term because the plaintiff's infringement theory depends on extending its meaning from compiled instructions (like bytecode) to structured data.
Intrinsic Evidence for Interpretation
- Evidence for a Broader Interpretation: The specification states that "code represents at least some information that must be translated by the software application before it can be implemented on the machine processor" (’897 Patent, col. 4:30-34). A party could argue that JSON data must be "translated" (i.e., parsed) by the application before it can be "implemented" (i.e., used to render a new user interface element).
- Evidence for a Narrower Interpretation: The complaint cites a prior construction of "code" as "information that must be translated before it can be executed on a processor" (Compl. ¶ 17, fn. 6). A party could argue that data like JSON is parsed and interpreted, but not "executed" on a processor in the same sense as compiled instructions. The specification also gives "Java Byte Code" as an example of "intermediary code," suggesting the term refers to a form of programmatic instructions rather than passive data (’897 Patent, col. 2:49-50).
The Term: "computer-executable instructions"
Context and Importance
This term is defined in opposition to "code." The plaintiff's infringement theory hinges on mapping this term to the runtime environment (ART/CLR) and "code" to the application logic. The viability of this mapping is critical.
Intrinsic Evidence for Interpretation
- Evidence for a Broader Interpretation: The complaint cites a prior construction as "computer instructions that can be directly executed on a processor" (Compl. ¶ 17). A party could argue that the native machine code of a runtime environment like ART or CLR fits this definition perfectly, as it runs directly on the device's CPU.
- Evidence for a Narrower Interpretation: A party could argue that, in the context of the patent, the term refers to the entirety of a traditionally compiled application (e.g., a fully compiled C++ binary), which is distinct from "intermediary code" like bytecode. They may argue the patent does not contemplate separating a runtime environment from the application it hosts in this manner.
VI. Other Allegations
Indirect Infringement
The complaint alleges both induced and contributory infringement. Inducement is based on allegations that Defendant instructs and encourages customers to download and use the infringing applications (Compl. ¶¶ 41, 43). Contributory infringement is based on allegations that the Accused Instrumentalities are not staple articles of commerce and are especially adapted for infringement (Compl. ¶¶ 44, 63).
Willful Infringement
Willfulness is alleged based on Defendant's knowledge of the patents "at least since the filing of the original complaint" (Compl. ¶¶ 31, 49, 69). This is a standard allegation of post-suit willfulness.
VII. Analyst’s Conclusion: Key Questions for the Case
- A core issue will be one of definitional scope: Can the term "code," which the patent specification and a prior court construction link to information that is "translated before it can be executed on a processor," be construed broadly enough to read on structured data formats like JSON, which are parsed by an application rather than executed in the manner of bytecode?
- A key evidentiary question will be one of technical mapping: Does the accused system’s architecture, which separates a general-purpose runtime environment (like ART or CLR) from the application logic it runs, align with the patents’ claimed distinction between "computer-executable instructions" and "code"? The resolution of this question will likely depend on expert testimony regarding how these systems operate and how the patent's claims apply to modern application frameworks.
- A central legal question will be the persuasive effect of prior proceedings: How will the court treat the claim constructions from the S3G v. Unikey litigation and the prosecution history arguments cited by the plaintiff? The parties’ ability to either leverage or distinguish those prior interpretations will be critical in shaping the claim construction and infringement analyses.