DCT
5:25-cv-00119
S3G Technology LLC v. GNC Holdings LLC
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: GNC Holdings, LLC (Delaware)
- Plaintiff’s Counsel: PARKER, BUNT & AINSWORTH, P.C.
- Case Identification: 5:25-cv-00119, E.D. Tex., 08/08/2025
- Venue Allegations: Plaintiff alleges venue is proper in the Eastern District of Texas because Defendant maintains a regular and established place of business in Texarkana, Texas, and has committed alleged acts of infringement within the district.
- Core Dispute: Plaintiff alleges that Defendant’s mobile applications and associated backend server systems infringe four patents related to methods for efficiently modifying software applications on networked remote devices.
- Technical Context: The technology concerns updating client-server applications by transmitting small "dialogue modules" containing interpreted "code" rather than resending entire compiled applications, aiming to conserve network bandwidth and improve efficiency.
- Key Procedural History: The complaint references a prior case, S3G Tech. LLC v. Unikey Techs., Inc., in which a court in the same district previously construed key terms from the asserted patent family, including "computer-executable instructions," "code," and "dialogue module." The complaint also notes that during prosecution, the U.S. Patent Examiner found the claimed inventions to be distinguishable from the prior art of record.
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Earliest Priority Date for ’124, ’140, ’571, and ’995 Patents |
| 2013-10-29 | U.S. Patent No. 8,572,571 Issues |
| 2018-04-10 | U.S. Patent No. 9,940,124 Issues |
| 2019-08-20 | U.S. Patent No. 10,387,140 Issues |
| 2023-05-30 | U.S. Patent No. 11,662,995 Issues |
| 2025-06-04 | Last Updated Date for Accused GNC Android App |
| 2025-06-18 | Last Updated Date for Accused GNC iOS App |
| 2025-08-08 | Complaint Filed |
II. Technology and Patent(s)-in-Suit Analysis
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 patent addresses the difficulty of distributing updated software to a large number of remote devices, particularly over wireless networks with limited bandwidth. Transmitting an entire newly compiled application for every modification is described as inefficient, time-consuming, and potentially infeasible (Compl. ¶¶15-16; ’124 Patent, col. 2:39-64).
- The Patented Solution: The invention proposes a system architecture involving a terminal machine, a service provider machine, and an update server machine. Software applications on the terminal and service provider machines are structured with two distinct components: "computer-executable instructions" that run directly on a processor, and "code" that must first be translated by the application. To modify the application's behavior (e.g., change a user dialogue), the update server sends a small "dialogue module" containing new or updated "code." This module alters the application's function without requiring the replacement of the larger, underlying computer-executable instructions, thereby saving bandwidth (Compl. ¶¶17-18; ’124 Patent, col. 4:25-40, FIG. 1). FIG. 1 of the patent, reproduced in the complaint, illustrates this three-machine architecture, showing the update server machine (102) communicating with both the terminal machine (120) and the service provider machine (110) (Compl. ¶17).
- Technical Importance: This architectural separation of directly executable instructions from translatable code aims to enable more dynamic and efficient software updates in networked environments, a key challenge in the proliferation of mobile and remote computing devices (’124 Patent, col. 6:56-63).
Key Claims at a Glance
- The complaint asserts at least independent claim 1 (Compl. ¶33).
- Essential elements of claim 1 (a method) include:
- Displaying a first prompt by running a terminal application comprising first computer-executable instructions and first code.
- Accepting a first data entry at the terminal machine.
- Communicating information to a service provider machine running a provider application comprising second computer-executable instructions and second code.
- Storing at least a portion of the information in memory for analysis.
- 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, the second code, and the first updated code comprise intermediate code.
- The complaint does not explicitly reserve the right to assert dependent claims for this patent.
U.S. Patent No. 10,387,140 - Modification of Terminal and Service Provider Machines Using an Update Server Machine
- Issued: August 20, 2019
The Invention Explained
- Problem Addressed: Similar to the ’124 Patent, the ’140 Patent addresses the technical problems associated with updating software on numerous remote devices over networks with limited data transfer capacity (Compl. ¶¶14-16; ’140 Patent, col. 2:45-64).
- The Patented Solution: The ’140 patent claims a method for conducting a dialogue between a terminal machine and a service provider machine. The method relies on the same two-part software structure (directly executable instructions and translatable code) on both machines. An update is facilitated by receiving "third code" at the terminal machine, which modifies the existing "first code" to adapt the terminal application for a modified dialogue sequence. This approach avoids transmitting a full application update (’140 Patent, Abstract; col. 4:25-40). FIG. 2 of the patent, reproduced in the complaint, depicts the specific two-part structure of the terminal application (122) and service provider application (112), showing separate computer-executable instructions (224, 214) and code (222, 212) (Compl. ¶18).
- Technical Importance: The claimed method provides a specific technical pathway for achieving lightweight, over-the-air updates to application logic, which was a significant consideration for the efficient operation of early mobile application ecosystems (’140 Patent, col. 6:56-63).
Key Claims at a Glance
- The complaint asserts at least independent claim 1 (Compl. ¶52).
- Essential elements of claim 1 (a method) include:
- Displaying a first prompt via a terminal application comprising first computer-executable instructions and first code.
- Receiving entry of first data.
- Communicating information to a provider application comprising second computer-executable instructions and second code.
- Storing at least a portion of the information in memory for analysis.
- Receiving, at the terminal machine, third code that modifies at least a portion of the first code to produce first updated code.
- The first updated code adapts the terminal application to conduct a modified dialogue sequence.
- Receiving the third code is performed in response to the terminal machine satisfying a trigger condition.
- The terminal and service provider machines include different types of processors, rendering their respective computer-executable instructions non-interoperable.
- The complaint does not explicitly reserve the right to assert dependent claims for this patent.
Multi-Patent Capsule: 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: This patent claims a system, rather than a method, for modifying applications. It describes a three-part system comprising an update server machine, a terminal machine, and a service provider machine. The update server sends dialogue modules to the other two machines to modify their respective applications, which are composed of separate computer-executable instructions and code, without modifying the computer-executable instructions themselves (Compl. ¶¶90-94).
- Asserted Claims: At least claim 2 (an independent system claim) (Compl. ¶89).
- Accused Features: The accused system, comprising user devices (e.g., smartphones) as update servers, Android devices as terminal machines, and GNC servers as service provider machines, is alleged to embody the claimed three-part structure for modifying the GNC app (Compl. ¶¶91-93).
Multi-Patent Capsule: U.S. Patent No. 11,662,995 - Network Efficient Location-Based Dialogue Sequence Using Virtual Processor
- Issued: May 30, 2023
- Technology Synopsis: This patent claims a method for conducting a dialogue sequence between two user devices facilitated by one or more provider applications. The method involves sending authorizations to each device, receiving "second code" from a first device to supplement "first code" on the provider application, and then sending "third code" to the second device after determining it meets certain criteria, facilitating its part of the dialogue (Compl. ¶¶108-115).
- Asserted Claims: At least claim 1 (an independent method claim) (Compl. ¶107).
- Accused Features: The complaint alleges that when a user interacts with the GNC website (first user device) and the GNC mobile app (second user device), the GNC server (provider application) facilitates a dialogue sequence that infringes this patent. The creation of a "Favorites item" on the website is alleged to generate code that is later sent to the mobile app (Compl. ¶¶109-111).
III. The Accused Instrumentality
Product Identification
- The "Accused Instrumentalities" or "Accused System" are identified as GNC’s mobile applications for Android and iOS (collectively, "Defendant app") and the associated systems, servers, and software that support them (Compl. ¶8).
Functionality and Market Context
- The accused GNC mobile app allows users to interact with GNC's backend servers to perform functions such as reviewing, removing, or ordering from a list of "Favorites items" (Compl. ¶35).
- The complaint alleges a specific technical architecture: the Android app consists of the Android Runtime (ART) as "computer executable instructions" and the app’s bytecode as "code" (Compl. ¶35). The backend server is alleged to run a .Net application where the Common Language Runtime (CLR) comprises the "computer-executable instructions" and the .Net program comprises the "code" (Compl. ¶37).
- Updates to content, such as a user's list of "Favorites items," are allegedly sent from the server to the mobile app in JSON format. The complaint frames these JSON data transmissions as "terminal dialogue modules" that update the app's "code" (the bytecode) to reflect the new list (Compl. ¶39).
IV. Analysis of Infringement Allegations
U.S. Patent No. 9,940,124 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 terminal application comprising first computer-executable instructions and first code | The GNC app (terminal application) displays prompts to the user. The app is alleged to comprise the Android Runtime (first computer-executable instructions) and the app's bytecode (first code). | ¶35 | col. 7:56-61 |
| accepting a first data entry at the terminal machine | The GNC app accepts user input, such as a selection to review or order a "Favorites" item. | ¶36 | col. 12:1-12 |
| communicating information associated with the first data entry from the terminal machine to the service provider machine... [which] uses a provider application comprising second computer-executable instructions and second code | User selections are communicated to the GNC server. The server application is alleged to be a .Net application comprising the CLR (second computer-executable instructions) and the .Net program (second code). | ¶37 | col. 8:26-31 |
| storing at least a portion of the information associated with the first data entry in memory for analysis | The GNC server stores user data, such as the list of "Favorites items," for analysis and future display. | ¶38 | col. 12:35-42 |
| 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 GNC app on the user's phone receives information from the server, for example in JSON format, representing an updated list of "Favorites" items. This is alleged to be a "terminal dialogue module" that updates the app's bytecode ("first code"). | ¶39 | col. 8:63-9:3 |
| 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 code allegedly enables the app to display a new prompt, such as the ability to access the newly added "Favorites" items. | ¶39 | col. 12:43-50 |
Identified Points of Contention
- Scope Question: A central question may be whether receiving a data object (e.g., JSON) that describes content (a "Favorites" list) constitutes "receiving... a terminal dialogue module that updates at least a portion of the first code." A court may need to determine if this is merely data being rendered by the application, or if it meets the patent's more specific requirement of structurally updating the application's "code" itself.
- Technical Question: What evidence does the complaint provide that the app's bytecode is functionally "updated" by a JSON payload, as opposed to the application's executable instructions simply parsing the JSON data and displaying the result? The distinction between data for an application and code that modifies an application may be a key technical dispute.
U.S. Patent No. 10,387,140 Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| ... a terminal application comprising first computer-executable instructions and first code... a provider application comprising second computer-executable instructions and second code | The complaint repeats the allegation that the GNC app (Android Runtime + bytecode) and server application (CLR + .NET program) embody this two-part structure. | ¶¶54, 56 | col. 7:56-61 |
| receiving, at the terminal machine, third code that modifies at least a portion of the first code to produce first updated code | The GNC app receives JSON data from the server (alleged "third code") which allegedly modifies the app's bytecode ("first code") to reflect, for example, a newly saved "Favorites" item. | ¶58 | col. 8:63-9:3 |
| wherein receiving the third code is performed in response to the terminal machine satisfying a trigger condition | The complaint alleges the "third code" is received in response to a trigger condition such as a user action (e.g., connecting to the network or accessing the app), or based on location/proximity. | ¶59 | col. 14:1-10 |
| wherein the terminal machine and the service provider machine include different types of processors, whereby the first computer-executable instructions are not able to be executed on the service provider machine... | The complaint alleges that the mobile device processor (e.g., ARM-based) is different from the server processor (e.g., x86-based), and that instructions compiled for one cannot run on the other. | ¶61 | col. 1:47-51 |
Identified Points of Contention
- Scope Question: Does a user action like "accessing the Defendant app" constitute a "trigger condition" in the technical sense required by the claim, or is it merely the normal operation of a client-server application initiating a data request?
- Technical Question: The claim requires that the different processor types render the respective computer-executable instructions non-interoperable. The complaint alleges this is met by the use of ARM vs. x86 architectures (Compl. ¶61). A court will examine whether this architectural difference satisfies the specific claim language regarding the non-executability of the "first" and "second" computer-executable instructions on the opposing machines.
V. Key Claim Terms for Construction
Term: "code"
- Context and Importance: The distinction between "code" (which requires translation) and "computer-executable instructions" (which execute directly) is the central technical premise of the asserted patents. The infringement case depends on construing the accused app's bytecode as "code." Practitioners may focus on this term because the plaintiff's infringement theory hinges on it, and the complaint heavily relies on a prior judicial construction of the term.
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The specification provides general context of software being written in languages like Java, which is then compiled into intermediary code like Java Byte Code that is not specific to one processor (’140 Patent, col. 1:47-67).
- Evidence for a Narrower Interpretation: The specification explicitly defines the term, stating that "[t]he code represents at least some information that must be translated by the software application before it can be implemented on the machine processor" (’140 Patent, col. 4:32-36). The complaint also 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. ¶18, fn. 6).
Term: "dialogue module"
- Context and Importance: Plaintiff's theory characterizes a JSON data payload as a "dialogue module." The viability of the infringement claim may depend on whether this characterization is consistent with the patent's definition of the term.
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The specification describes the dialogue module as containing "portions of code and/or instructions that are able to modify the dialogue protocol" (’140 Patent, col. 7:28-32), which could be argued to encompass data that dictates application behavior.
- Evidence for a Narrower Interpretation: The complaint cites a construction from the Unikey case holding that the term refers to "a particular type of structure rather than to any structure for performing a function" and clarifies it "can contain code or other data" (Compl. ¶22). This suggests it is a structural data element, but its scope relative to a simple data file remains a potential point of contention.
VI. Other Allegations
- Indirect Infringement: The complaint alleges inducement on the basis that Defendant instructs users to download and use the infringing app, intending for them to perform the patented methods (Compl. ¶¶43, 45, 67, 69). Contributory infringement is alleged on the grounds that the Accused Instrumentalities are not staple articles of commerce and are especially adapted for infringement (Compl. ¶¶46, 70).
- Willful Infringement: The complaint alleges Defendant has had actual knowledge of the patents "at least since the filing of this Complaint" (Compl. ¶¶32, 51, 88, 106). This allegation supports a claim for post-filing willful infringement.
VII. Analyst’s Conclusion: Key Questions for the Case
- A core issue will be one of definitional scope: can the patent term "dialogue module," which updates an application's "code," be construed to cover a standard JSON data transmission from a server that provides content for a mobile application to render? The case may turn on the distinction between a data payload that an application interprets and a module that structurally modifies the application’s underlying translatable code.
- A key evidentiary question will be one of technical implementation: what factual evidence will be presented to demonstrate that the GNC app's bytecode is functionally "updated" by server communications, as the patents claim, versus merely parsing and displaying data, as is common in client-server architectures?
- A significant legal question will be the applicability of prior constructions: how will the claim constructions from the Unikey case, which Plaintiff advances as supportive, apply to the specific technical architecture of GNC’s widely used consumer-facing applications? The defendant may argue for different constructions or that its system is factually distinguishable even under the prior constructions.