Pros of moonlight-embedded

• Designed specifically for embedded systems and low-power devices
• Optimized for performance on resource-constrained hardware
• Supports a wide range of platforms, including Raspberry Pi and other SBCs

Cons of moonlight-embedded

• May have fewer features compared to the full Moonlight client
• Potentially more complex setup process for non-technical users
• Limited graphical user interface options

Code Comparison

Both repositories contain similar code structures, as they are part of the same project. Here's a snippet from the main.c file in both repositories:

// moonlight-embedded
int main(int argc, char* argv[]) {
  CONFIGURATION config;
  config_parse(argc, argv, &config);
  // ...
}

// moonlight-embedded
int main(int argc, char* argv[]) {
  CONFIGURATION config;
  config_parse(argc, argv, &config);
  // ...
}

The code structure and functionality appear to be identical in both repositories. The main differences lie in the specific implementations and optimizations for embedded systems in the moonlight-embedded repository.

Pros of Sunshine

• Cross-platform support (Windows, Linux, macOS)
• Supports both NVIDIA and AMD GPUs
• More customizable streaming settings

Cons of Sunshine

• Requires more setup and configuration
• Less mature project with potential stability issues
• Smaller community and less documentation

Code Comparison

Sunshine (C++):

void VideoEncoder::encode(const AVFrame* frame) {
    int ret = avcodec_send_frame(_codec_ctx, frame);
    if (ret < 0) {
        throw std::runtime_error("Error sending frame for encoding");
    }
}

Moonlight Embedded (C):

int encode(AVCodecContext *encoder_ctx, AVFrame *frame, AVPacket *pkt) {
    int ret = avcodec_send_frame(encoder_ctx, frame);
    if (ret < 0) {
        fprintf(stderr, "Error sending frame for encoding\n");
        return ret;
    }
    return 0;
}

Both projects use the FFmpeg library for video encoding, but Sunshine uses C++ with exception handling, while Moonlight Embedded uses C with error code returns.

Moonlight Embedded is a more established project with better stability and documentation, focusing on client-side streaming. Sunshine, on the other hand, offers more flexibility and cross-platform support but may require more technical expertise to set up and use effectively.

Pros of Moonlight-qt

• Cross-platform support (Windows, macOS, Linux)
• User-friendly graphical interface
• More frequent updates and active development

Cons of Moonlight-qt

• Higher system requirements
• Potentially less performant on low-end devices
• May have more dependencies

Code Comparison

Moonlight-qt (C++/Qt):

void StreamSegue::startUp()
{
    m_Computer = m_ComputerManager->getComputer(m_ComputerName);
    if (m_Computer == nullptr) {
        emit displayLaunchError(tr("Computer not found"));
        return;
    }
}

Moonlight-embedded (C):

static int moonlight_init(void)
{
    char* config_file = get_config_file();
    if (config_file == NULL) {
        fprintf(stderr, "Not enough memory\n");
        exit(EXIT_FAILURE);
    }
}

Moonlight-qt uses C++ with Qt framework, providing a more structured and object-oriented approach. Moonlight-embedded uses C, which can be more lightweight but potentially less maintainable for complex applications. The qt version focuses on GUI elements and error handling, while the embedded version deals with low-level operations like memory management.