DCT
2:25-cv-00689
S3G Technology LLC v. Retail Services & Systems Inc
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: Retail Services & Systems, Inc., d/b/a Total Wine & More (Maryland)
- Plaintiff’s Counsel: PARKER, BUNT & AINSWORTH, P.C.
- Case Identification: 2:25-cv-00689, E.D. Tex., 07/07/2025
- Venue Allegations: Plaintiff alleges venue is proper because Defendant maintains a regular and established place of business in the district, distributes the accused mobile applications to customers in the district, and committed the alleged acts of infringement there.
- Core Dispute: Plaintiff alleges that Defendant’s mobile ordering applications and associated backend systems infringe three patents related to methods and systems for efficiently modifying remote software applications.
- Technical Context: The technology addresses updating distributed software, such as mobile applications, by sending small "dialogue modules" to alter application behavior, thereby avoiding the need to transmit large, fully recompiled application files over bandwidth-constrained networks.
- Key Procedural History: The complaint references prior litigation (S3G Tech. LLC v. Unikey Techs., Inc.), citing specific claim constructions from that case for key terms such as "code" and "dialogue module." The complaint also notes that the asserted patents were found allowable by the U.S. Patent Office over prior art and that other parties have licensed the patent portfolio, in part due to the "high burden of proving invalidity."
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Priority Date for ’897, ’124, and ’758 Patents |
| 2015-07-14 | U.S. Patent No. 9,081,897 Issues |
| 2016-04-05 | U.S. Patent No. 9,304,758 Issues |
| 2018-04-10 | U.S. Patent No. 9,940,124 Issues |
| 2025-06-09 | Last Update Date for Accused Android App |
| 2025-06-11 | Last Update Date for Accused iOS App |
| 2025-07-07 | Complaint Filing Date |
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"
- The Invention Explained:
- Problem Addressed: The patents describe the difficulty of updating software applications distributed across many devices, particularly over large geographic areas or wireless networks. Transmitting a newly compiled version of an entire application can be infeasible due to file size, network bandwidth limitations, and time constraints (Compl. ¶¶12-14; ’124 Patent, col. 2:12-56).
- The Patented Solution: The invention proposes a three-entity computer system (update server, terminal machine, service provider machine) that modifies applications without replacing them entirely. It achieves this by sending small "dialogue modules" containing "code" from the update server. This "code" is distinct from the application's core "computer-executable instructions"; it must be translated or interpreted by the application to change its behavior, such as altering a sequence of prompts (Compl. ¶¶15-16, 22; ’124 Patent, col. 4:30-40). The complaint references FIG. 1, which provides a high-level diagram of the three-machine system architecture communicating wirelessly (Compl. ¶15, p. 7).
- Technical Importance: This architectural approach was designed to reduce network bandwidth utilization and improve the efficiency of developing and modifying applications running on remote devices (Compl. ¶¶22, 24).
- Key Claims at a Glance:
- The complaint asserts independent claim 1 (Compl. ¶31).
- The essential elements of system claim 1 include:
- An "update server machine" for sending a "terminal dialogue module" and a "provider dialogue module."
- A "terminal machine" running a "terminal application" that comprises a "first set of computer-executable instructions" (able to execute directly on a processor) and a "first set of code" (not able to execute directly).
- A "service provider machine" running a "provider application" that similarly comprises a "second set of computer-executable instructions" and a "second set of code."
- The "terminal dialogue module" modifies the "first set of code" to produce updated code, adapting the terminal application, without modifying the "first set of computer-executable instructions."
- The "provider dialogue module" similarly modifies the "second set of code" on the service provider side.
- The complaint does not explicitly reserve the right to assert other claims but infringement is alleged for "one or more claims" (Compl. ¶31).
U.S. Patent No. 9,940,124 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
- The Invention Explained:
- Problem Addressed: As a continuation of the same patent family, the ’124 Patent addresses the same technical problems as the ’897 Patent, namely the inefficiency of updating distributed software applications via conventional methods (Compl. ¶¶12-14).
- The Patented Solution: The ’124 Patent claims a method for conducting and modifying a dialogue between a terminal and service provider machine. The method involves receiving a "terminal dialogue module" that updates a portion of the application's "first code" to produce "first updated code," which in turn adapts the application to display a modified dialogue sequence. The patent distinguishes between directly executable instructions and "intermediate code" that must be translated (Compl. ¶¶15-16, 55; ’124 Patent, col. 4:30-40, Claim 1). The complaint references FIG. 2, which illustrates the specific software structure of the applications, distinguishing between computer-executable instructions (224, 214) and translatable code (222, 212) (Compl. ¶16, p. 7).
- Technical Importance: This method provides a mechanism for dynamic modification of application behavior on remote devices, aiming to reduce data transfer and improve system responsiveness (Compl. ¶24).
- Key Claims at a Glance:
- The complaint asserts independent claim 1 (Compl. ¶49).
- The essential elements of method claim 1 include:
- Displaying a first prompt on a terminal machine by running a terminal application comprising "first computer-executable instructions" and "first code."
- Accepting a first data entry.
- Communicating information from the terminal machine to a service provider machine.
- 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 "first updated code" adapts the terminal application to display a second prompt for a modified dialogue sequence.
- At least one of the "first code," "second code" (on the server), and "first updated code" comprise "intermediate code."
- The complaint alleges infringement of "one or more claims" (Compl. ¶49).
U.S. Patent No. 9,304,758 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
- Technology Synopsis: The ’758 Patent, also from the same family, claims a method for conducting a dialogue between a terminal and service provider machine. The technology focuses on modifying the dialogue sequence by receiving a "terminal dialogue module" that replaces a portion of the application's "first code" to produce "first updated code," with a specific requirement that at least some of this code is Java Byte code (Compl. ¶73).
- Asserted Claims: Independent Claim 1 (Compl. ¶68).
- Accused Features: The accused features are the same as for the other asserted patents: the Total Wine & More mobile application and server system, specifically the method of updating the dialogue for features like "My Lists" (Compl. ¶¶69-73).
III. The Accused Instrumentality
Product Identification
- The accused instrumentalities are the Total Wine & More mobile applications for Android and iOS, along with the supporting backend systems, including servers and software (collectively, the "Accused System") (Compl. ¶7).
Functionality and Market Context
- The Accused System provides mobile ordering and account management services. The complaint focuses on functionality such as "My Lists," where a user can review, order, or delete items. This interaction requires communication between the user's device and the Defendant's server (Compl. ¶¶33-34, 51). The complaint alleges that when a user interacts with a feature like "My Lists," information in a format such as JSON is sent from the server to the app, which constitutes the claimed "dialogue module" that modifies the app's behavior (Compl. ¶¶13, 24, 33).
- The complaint alleges that Defendant derives a significant portion of its revenue from the promotion, sale, and use of the Accused System in the district (Compl. ¶4).
IV. Analysis of Infringement Allegations
'897 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| one or more update server machines comprising a processor and operable for sending a terminal dialogue module...and a provider dialogue module | A user's device or Defendant's server acts as an update server, sending a "dialogue module" (e.g., data for a "My Lists" item) to the terminal and provider machines. | ¶33 | col. 15:20-29 |
| wherein the terminal machine is configured to run a terminal application...[which] comprises a first set of computer-executable instructions and a first set of code | The user's Android smartphone is the terminal machine. The app's runtime environment (Android Runtime or ART) is alleged to be the "computer-executable instructions," while the app's bytecode is alleged to be the "code." | ¶34 | col. 15:31-43 |
| wherein the first set of code is not able to execute directly on the terminal processor | The app's bytecode is not able to execute directly and must be interpreted or compiled by the ART. | ¶34 | col. 15:41-43 |
| wherein the service provider machine is configured to run a provider application...[which] comprises a second set of computer-executable instructions and a second set of code | Defendant's server is the service provider machine. The .Net runtime environment (CLR) is the "computer-executable instructions," and the server application program is the "code." | ¶35 | col. 15:44-55 |
| wherein the terminal dialogue module modifies the first set of code to produce a first set of updated code...wherein the terminal dialogue module does not modify the first set of computer-executable instructions | Information for a "My Lists" item (the dialogue module) modifies the app's bytecode (the code) to adapt the dialogue sequence, but does not modify the underlying ART (the computer-executable instructions). | ¶¶36, 18 | col. 15:56-65 |
'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...by running a terminal application, the terminal application comprising first computer-executable instructions and first code | The Total Wine app displays a prompt related to a user's "My Lists." The app is alleged to comprise the Android Runtime (instructions) and bytecode (code). | ¶51 | col. 2:65-3:2 |
| accepting a first data entry at the terminal machine | The user interacts with the app, for example, to create, review, or order an item from "My Lists." | ¶52 | col. 2:65-3:2 |
| communicating information...from the terminal machine to the service provider machine | The user's action (e.g., ordering an item) is communicated from the mobile app to Defendant's server. | ¶53 | col. 4:60-63 |
| 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 data) from the server that updates the "My Lists" data, which is alleged to be the "terminal dialogue module" updating the app's bytecode ("first code"). | ¶55 | col. 8:36-40 |
| wherein the first updated code adapts the terminal application to display a second prompt for the terminal machine's portion of a modified dialogue sequence | The updated list appears on the user's device, which represents a modified dialogue sequence with new prompts or options. | ¶55 | col. 8:36-54 |
Identified Points of Contention
- Scope Questions: A central dispute may arise over the interpretation of the distinct roles of "computer-executable instructions" and "code." The complaint alleges that a mobile operating system's runtime environment (e.g., Android's ART) constitutes the "computer-executable instructions," while the application's own program (e.g., bytecode) constitutes the "code." The court will have to determine if this mapping aligns with the patent's definitions, where "code" is defined as "information that must be translated...before it can be implemented" (’124 Patent, col. 4:30-40).
- Technical Questions: The case may turn on whether the routine exchange of transactional data (e.g., a JSON object representing a shopping list) qualifies as a "dialogue module" that "modifies" the application's "code." An alternative interpretation could be that the patent requires a more structured update mechanism specifically for altering application logic, rather than just updating application data content.
- Scope Questions: The complaint alleges that a user's device can act as both the "terminal machine" and the "update server machine" (Compl. ¶33). The relationship between the three distinct machines required by the claims (terminal, service provider, update server) and the two primary components of the accused system (user device, server) may be a point of contention.
V. Key Claim Terms for Construction
The Term: "code"
- Context and Importance: This term's definition is fundamental to the infringement theory. The patent's claimed invention relies on the specific architectural separation between directly executable "instructions" and translatable "code." The validity of the infringement allegations hinges on whether an application's bytecode or a .Net program fits the patent's definition of "code" while the underlying runtime environment (ART/CLR) fits the definition of "instructions."
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The complaint cites a prior construction from the Unikey case defining "code" as "information that must be translated before it can be executed on a processor" (Compl. ¶16, fn. 5). This could be argued to cover interpreted data formats like JSON or intermediate representations like bytecode.
- Evidence for a Narrower Interpretation: The specification explicitly 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" (’124 Patent, col. 4:30-40). This language, focusing on implementation by the processor, could be argued to exclude simple data content and refer more narrowly to executable scripts or logic definitions.
The Term: "dialogue module"
- Context and Importance: This term defines the vehicle for the claimed software modification. The dispute will likely question whether any data packet that influences a user interface, like the JSON alleged in the complaint (Compl. ¶24), constitutes a "dialogue module," or if the term implies a more specific, structured package designed for software updates.
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The complaint highlights language from the Unikey litigation suggesting a "dialogue module" can contain "code or other data and can be communicated" (Compl. ¶20). This could support the theory that a JSON object containing data for a list is a "dialogue module."
- Evidence for a Narrower Interpretation: The same Unikey decision quoted in the complaint also states the term refers to a "particular type of structure rather than to any structure for performing a function" (Compl. ¶20). This suggests a specific format is required. Furthermore, the specification notes that in a preferred embodiment, the "dialogue module is less than 1 Mb to facilitate communication over a network with limited data transfer capacity," framing it as an efficient alternative to sending a large application file, which may distinguish it from routine, small transactional data packets (’124 Patent, col. 6:61-63).
VI. Other Allegations
- Indirect Infringement: The complaint alleges induced infringement based on Defendant providing the mobile applications and instructing customers to download and use them in an infringing manner (Compl. ¶¶40, 42, 59, 61). Contributory infringement is alleged on the basis that the Accused System is not a staple article of commerce and is especially adapted for infringing the patents (Compl. ¶¶43, 62).
- Willful Infringement: Willfulness is alleged based on Defendant's knowledge of the patents "at least since the filing of this Complaint" (Compl. ¶¶30, 48, 67). This frames a basis for potential post-suit willfulness.
VII. Analyst’s Conclusion: Key Questions for the Case
- A core issue will be one of technical and definitional mapping: can the plaintiff successfully argue that a modern mobile application architecture, consisting of an application's program (e.g., bytecode) running on a managed runtime environment (e.g., ART), maps to the patent's claimed separation between translatable "code" and directly-executable "computer-executable instructions"?
- A key question of functional scope will be whether the routine, dynamic exchange of transactional data (such as a JSON object updating a shopping list) constitutes the claimed act of modifying an application with a "dialogue module," or if the patent's claims, read in light of the specification, are limited to a more fundamental software update mechanism distinct from normal data flow.
- An evidentiary question will center on the system's structure: does the accused two-part system (client device and server) satisfy the claims' requirement for a three-part architecture (terminal machine, service provider machine, and a distinct update server machine), particularly given the complaint's allegation that a single device can embody different claimed machines?